(in-package :lcc)

(defun specify-module (def attrs)

(when (> (length attrs) 0) (error (format nil "wrong attributes ~A" attrs)))

(let* ((name (specify-decl-name< (nth 1 def)))

(clauses (nthcdr 2 def))

(module-specifier (make-specifier name '|@MODULE| nil nil nil nil nil nil nil))

(tmp-module-spec *module-spec*)

(tmp-module-path *module-path*))

(setq *module-spec* module-specifier)

(setq *module-path* (append *module-path* (list (name module-specifier))))

(let ((attributes '()))

(dolist (clause clauses)

(if (consp clause)

(let ((construct (car clause)))

(cond ((find (char (symbol-name construct) 0) "@#")

(add-inner (specify-preprocessor clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|static|) (push clause attributes))

((key-eq construct '|decl|) (push clause attributes))

((key-eq construct '|inline|) (push clause attributes))

((key-eq construct '|register|) (push clause attributes))

((key-eq construct '|auto|) (push clause attributes))

((key-eq construct '|extern|) (push clause attributes))

((key-eq construct '|include|) (setq attributes '()))

((key-eq construct '|var|)

(add-inner (specify-variable clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|func|)

(add-inner (specify-function clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|method|)

(add-inner (specify-function clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|enum|)

(add-inner (specify-enum clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|struct|)

(add-inner (specify-struct clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|union|)

(add-inner (specify-union clause attributes) module-specifier)

(setq attributes '()))

((key-eq construct '|module|)

(add-inner (specify-module clause attributes) module-specifier)

(setq attributes '()))

(t (error (format nil "unknown clause ~A in module ~A" construct name)))))

(error (format nil "syntax error ~A" clause)))))

(setq *module-path* tmp-module-path)

(setq *module-spec* tmp-module-spec)

module-specifier))

(defun compile-module (spec lvl globals &key ((:nested is-nested) nil))

(let ((name (name spec)))

(if *target-header*

(progn ; in header file

(maphash #'(lambda (in-name in-spec)

(case (construct in-spec)

('|@VAR| (compile-variable in-spec lvl globals :unique t))

('|@FUNC| (compile-function in-spec lvl globals :unique t))

('|@METHOD| (compile-function in-spec lvl globals :unique t))

('|@PREPROC| (compile-preprocessor in-spec lvl globals))

('|@ENUM| (compile-enum in-spec lvl globals :unique t))

('|@STRUCT| (compile-struct in-spec lvl globals :unique t))

('|@UNION| (compile-union in-spec lvl globals :unique t))

('|@MODULE| (compile-module in-spec lvl globals :nested t))

(otherwise nil)))

(inners spec))

;; (output "~&~A" (indent lvl))

;; (unless is-nested (set-ast-line (output "const ")))

;; (set-ast-line (output "struct "))

;; (if is-nested

;; (set-ast-line (output "~A_module {~%" (unique spec)))

;; (set-ast-line (output "~A_module {~%" name)))

;; (maphash #'(lambda (in-name in-spec)

;; (case (construct in-spec)

;; ('|@VAR| (compile-variable in-spec (1+ lvl) globals))

;; ('|@FUNC| (compile-function in-spec (1+ lvl) globals :type t)

;; (output ";~%"))

;; ('|@METHOD| (compile-function in-spec (1+ lvl) globals :type t)

;; (output ";~%"))

;; ('|@PREPROC| (compile-preprocessor in-spec (1+ lvl) globals))

;; ('|@TYPEDEF| (compile-typedef in-spec (1+ lvl) globals))

;; ('|@ENUM| (compile-enum in-spec (1+ lvl) globals))

;; ('|@STRUCT| (output "~&~A" (indent (1+ lvl)))

;; (output "struct ")

;; (set-ast-line (output "~A " (unique in-spec)))

;; (set-ast-line (output "~A" (name in-spec)))

;; (output ";~%"))

;; ('|@UNION| (output "~&~A" (indent (1+ lvl)))

;; (output "union ")

;; (set-ast-line (output "~A " (unique in-spec)))

;; (set-ast-line (output "~A" (name in-spec)))

;; (output ";~%"))

;; ('|@MODULE| (output "~&~A" (indent (1+ lvl)))

;; (output "struct ")

;; (set-ast-line (output "~A_module " (unique in-spec)))

;; (set-ast-line (output "~A" (name in-spec)))

;; (output ";~%"))

;; (otherwise nil)))

;; (inners spec))

;; (output "~&~A" (indent lvl))

;; (set-ast-line (output "} "))

;; (if is-nested

;; (set-ast-line (output ";~%"))

;; (set-ast-line (output "~A;~%" name)))

)

(progn ; in source file

(maphash #'(lambda (in-name in-spec)

(case (construct in-spec)

('|@VAR| (compile-variable in-spec lvl globals :unique t))

('|@FUNC| (compile-function in-spec lvl globals :unique t))

('|@METHOD| (compile-function in-spec lvl globals :unique t))

('|@PREPROC| (compile-preprocessor in-spec lvl globals))

('|@MODULE| (compile-module in-spec lvl globals :nested t))

(otherwise nil)))

(inners spec))

;; (output "~&~A" (indent lvl))

;; ;; (unless is-nested (set-ast-line (output "typedef ")))

;; (if is-nested

;; (progn

;; (set-ast-line (output "const struct "))

;; (set-ast-line (output "~A_module " (unique spec)))

;; (set-ast-line (output "~A " (unique spec))))

;; (progn

;; (set-ast-line (output "const struct "))

;; (set-ast-line (output "~A_module " name))

;; (set-ast-line (output "~A " name))))

;; (output "= { ~%")

;; (maphash #'(lambda (in-name in-spec)

;; (case (construct in-spec)

;; ('|@VAR| (output "~&~A" (indent (1+ lvl)))

;; (output ".")

;; (set-ast-line (output "~A " (name in-spec)))

;; (output "= ")

;; (set-ast-line (output "~A " (name in-spec)))

;; (output ",~%"))

;; ('|@FUNC| (output "~&~A" (indent (1+ lvl)))

;; (output ".")

;; (set-ast-line (output "~A " (name in-spec)))

;; (output "= ")

;; (set-ast-line (output "~A " (unique in-spec)))

;; (output ",~%"))

;; ('|@METHOD| (let ((name (name in-spec)))

;; (output "~&~A" (indent (1+ lvl)))

;; (output ".")

;; (set-ast-line (output "~A_~A " (car name) (cdr name)))

;; (output "= ")

;; (set-ast-line (output "~A " (unique in-spec)))

;; (output ",~%")))

;; ('|@PREPROC| (compile-preprocessor in-spec (1+ lvl) globals))

;; ('|@MODULE| (output "~&~A" (indent (1+ lvl)))

;; (output ".")

;; (set-ast-line (output "~A " (name in-spec)))

;; (output "= ")

;; (set-ast-line (output "~A " (unique in-spec)))

;; (output ",~%"))

;; (otherwise nil)))

;; (inners spec))

;; (output "~&~A" (indent lvl))

;; (output "};~%")

))))