;;; -*- Mode: LISP; Package: :cl-user; BASE: 10; Syntax: ANSI-Common-Lisp; ;-*-
;;;  Time-stamp: <2002-12-23 04:53:02>
;;;  Touched: Thu Oct 10 00:29:21 2002 <enometh@meer.net>
(in-package :CL-USER)
;;; HW3 CS555 Fall 02 for <darko@cs>
;;;
;;; External Dependencies:
;;;
;;; This project uses the ZEBU parser generator package from the cmu
;;; ai repositories.  Also requires MK-DEFSYSTEM from CLOCC at
;;; soresforge.
;;;
;;; This has been tested only with cmucl and makes assumptions that
;;; the Lisp implementation used is cmucl.
(defparameter *hw3-source-directory*
  (or (and *load-truename*
	   (make-pathname :directory (pathname-directory *load-truename*)))
      (ext:default-directory)))
(defparameter *hw3-binary-directory*
  (make-pathname :directory (append (pathname-directory *hw3-source-directory*)
				    (list "binary"))))

(ensure-directories-exist *hw3-binary-directory*)
#-mk-defsystem(require :defsystem) ;; say no to defsystem

(defparameter *zebu-directory* #p"/home/madhu/cmu/zebu/")
#+nil(defparameter *zebu-binary-directory* *hw3-binary-directory*)
(load (merge-pathnames "sysdcl.lisp" *zebu-directory*))


#+nil(defparameter *zebra-directory* #p"/home/madhu/cmu/zebra/")
#+nil(defparameter *zebra-binary-directory* *hw3-binary-directory*)
#+nil(load (merge-pathnames "sysdcl.lisp" *zebra-directory*))


(mk:defsystem "HW3"
    :depends-on ("ZEBU" #+nil  "ZEBRA")
    :source-pathname *hw3-source-directory*
    :binary-pathname *hw3-binary-directory*
    :components
    ((:file "core1-package")
     (:file "core1-pprinters")
     (:file "core1"
	    :documentation "hw4"
	    :depends-on ("core1-pprinters" "core1-package")
	    :language :ZEBU
	    :source-extension "zb"
	    :binary-extension "tab"
	    :compiler zebu-compile-file-1
	    :loader zebu-load-file-1)
     (:file "interp2" :documentation "interpreter for core1 hw6,7")
     (:file "pnf-package" :depends-on ("core1-package"))
     (:file "pnf" :depends-on ("pnf-package")
	    :documentation
	    "pnf classes pprinters interpreter and translator from core1 (9)")
     (:file "clos" :documentation "closure conversion (8)")
     (:file "ohaml-package")
     (:file "ohaml"
	    :documentation "hw3"
	    :language :ZEBU
	    :source-extension "zb"
	    :binary-extension "tab"
	    :compiler zebu-compile-file-1
	    :loader zebu-load-file-1)
     #+nil "fixes"
     #+nil
     (:file "interp2"
	    :language :ZEBRA
	    :source-extension "za"
	    :binary-extension "lisp"
		 :compiler zebra-compile-file-1
		 :loader zebra-load-file-1)))

(mk:load-system 'hw3 :compile-during-load  t)	

(defun parse-core1 (filename)
  (let ((zb:*current-grammar* (zb:find-grammar "core1"))
	(zb:*comment-brackets* '(("(*" . "*)"))))
    (zb:file-parser  (merge-pathnames filename *hw3-source-directory*))))

(defun parse-ohaml (filename)l
  (let ((zb:*current-grammar* (zb:find-grammar "ohaml"))
	(zb:*comment-brackets* '(("#|" . "|#"))))
    (zb:file-parser  (merge-pathnames filename *hw3-source-directory*))))

(defun interp (str)
  (let ((zb:*current-grammar* (zb:find-grammar "core1")))
    (warn "PARSING: ~A " str)    
    (let ((form (zb:read-parser str)))
      form)))
	  

#||
(declaim (optimize (speed 0) (safety 1) (debug 3)))
(setq a (car (parse-core1 "fact.c")))
(pnf::translate a)
(pnf::pnfinterp (pnf::translate a))
(interp "(app (abs 1234 int `2') int `0')")
(interp2 (interp "(app ISUB (record [int `111' int `1']))"))

(require :clm)

;;; we can read single expressions using #'zb:read-parser
(let ((teststrings1
       '("65656"
	 "(abs 23452 23452)"
	 "int `3792562706782356203'"
	 "float `-5632789.452389e-82'"
	 "char `f'"			; TODO escape sequences in :lex-cat
	 "(app iadd (record [int `444' 23]))")))
  (loop for str in teststrings1 do
	(warn "PARSING: ~A" str)
	(let ((result (ZB:read-parser str)))
	  (warn "--><~A> (~A)" result (type-of result)))))

;;; read in the factorial function from fact.c
(warn "~A"
      (setq a (zb:file-parser (merge-pathnames "fact.c" *hw3-source-directory*))))
(setq a (interp "(fix [(1234 (abs 10 int `10'))] int `1000')"))

||#