;;;;  -*- Mode: Lisp; Syntax: Common-Lisp; Package: SYSTEM -*-
;;;;
;;;;  Copyright (c) 2010-2012, Jean-Claude Beaudoin.
;;;;  Copyright by a number of previous anonymous authors
;;;;            presumed to be the same as for the rest of MKCL.
;;;;
;;;;    This program is free software; you can redistribute it and/or
;;;;    modify it under the terms of the GNU Lesser General Public
;;;;    License as published by the Free Software Foundation; either
;;;;    version 3 of the License, or (at your option) any later version.
;;;;
;;;;    See file '../Copyright' for full details.

;;; compile.pre.  Generated from compile.lsp.in by configure.
;;;
;;; This is the "compile" file for building MKCL. The purpose of this file is
;;;	- Compile the core of the Common-Lisp library (lsp, clos)
;;;	- Build an executable
;;;

(progn
  (setq *package* (find-package "SYSTEM"))
  (setq *features* (cons :mkcl-bootstrap *features*))
  )

;;;
;;; * Ensure that we have the whole of Common-Lisp before we start to compile
;;;
;;(load "bare.lsp" :verbose nil)
(let ((real-start (get-internal-real-time))
      (run-start (get-internal-run-time))
      real-end run-end)
  (load "bare.lsp" :verbose nil :external-format '(:ascii :lf))
  (setq run-end (get-internal-run-time)
	real-end (get-internal-real-time))
  (format *trace-output*
	  "~2&load real time : ~,3F secs~%~
           load run time  : ~,3F secs~2%"
	  (/ (- real-end real-start) internal-time-units-per-second)
	  (/ (- run-end run-start) internal-time-units-per-second))
  )


;;(setq compiler::*trace-cc* t)

#|
(setq *compile-verbose* t
      *compile-print* t
      compiler::*suppress-compiler-messages* nil
      compiler::*suppress-compiler-warnings* nil
      compiler::*suppress-compiler-notes* nil)
|#

(load "compile-utils.lsp" :external-format '(:ascii :lf))

;;;
;;; * Trick to make names shorter in C files
;;;
(si::reopen-package "CL")
(rename-package "CL" "CL" '("COMMON-LISP" "LISP"))


;(setq compiler::*compiler-break-enable* t) ;; to drop into the debugger on an error.
(setf compiler::*ld-flags* compiler::*external-ld-flags*
#|
      compiler::*ld-shared-flags*
      (concatenate 'base-string
		   "-shared  mkcl.dll " compiler::*ld-flags*)
      compiler::*ld-bundle-flags*
      #+:mingw32 ;; I bet this one is not even needed on mingw32! JCB
      (concatenate 'base-string
		   "-shared  mkcl.dll " compiler::*ld-flags*)
      #-:mingw32
      "-shared "
|#
      )

;;;
;;; * Compile and link Common-Lisp base library
;;;

(setq si::*keep-documentation* nil) ;; Remove documentation from compiled files

(let* (#+windows (compiler::*cc-flags* (concatenate 'string "-DMKCL_API " compiler::*cc-flags*))
       ;;(lsp-objects (compile-if-old "src:lsp;" +lisp-module-files+ :fasl-p nil))
       (lsp-objects (compile-if-old "./lsp/" +lisp-module-files+ :fasl-p nil))
       )
  (let* ((compiler::*compile-to-linking-call* nil))
    (setq lsp-objects 
	  (append lsp-objects
		  ;;(compile-if-old "src:clos;" +clos-module-files+ :fasl-p nil)
		  (compile-if-old "./clos/" +clos-module-files+ :fasl-p nil)
		  )))

  (let (;;(compiler::*suppress-compiler-messages* nil)
	;;(compiler::*suppress-compiler-warnings* nil)
	;;(compiler::*suppress-compiler-notes* nil)
	;;(*compile-verbose* t)
	;;(*compile-print* t)
	)
    (format t "~&;;About to build static library liblsp.a~%")
    (unless (compiler:build-static-library "lsp" :lisp-object-files lsp-objects)
      (mkcl:quit :exit-code 1))
    (format t "~&;;Done building liblsp.a!~%")
    ))

;;;
;;;
(let* ((compiler::*ld-shared-flags*
	#+unix
	;;"-shared     libmkclgc.a   -lgmp    -lm"
	"-shared     -lgmp    -lm"
	#+mingw64
	"-shared c:/Users/Jean-Claude/GNU2/mingw64/lib/libgmp.a -lws2_32    -lm"
	#+(or mingw32 cygwin)
	;;"-shared     -lws2_32 -lgmp    -lm"
	"-shared    -lws2_32 -lgmp    -lm"
	#+msvc 
	"-shared    @STATICLIBS@ @CLIBS@"
	)
       ;;(extra-ld-flags "")
       (extra-ld-flags #+unix (mkcl:bstr+ "-Wl,-soname,mkcl_" (si:mkcl-version) ".dll"))
       ;;#+windows
       ;;(compiler::*cc-flags* (concatenate 'string "-DMKCL_API " compiler::*cc-flags*))
       ;;(extra-args nil)
       )
  ;; #+(or mingw32 mingw64 cygwin)
  ;; (progn
  ;;   ;; We need these two to force dllwrap to export the symbols
  ;;   ;; in these libraries. Otherwise it will not be possible to
  ;;   ;; call functions from GMP or GC in code that embeds MKCL.
  ;;   (when (probe-file "libmkclgc.a")
  ;;     (push "libmkclgc.a" extra-args))
  ;;   ;; (when (probe-file "libmkclgmp.a")
  ;;   ;;   (push "libmkclgmp.a" extra-args))
  ;;   )
  (let (;;(compiler::*suppress-compiler-messages* nil)
	;;(compiler::*suppress-compiler-warnings* nil)
	;;(compiler::*suppress-compiler-notes* nil)
	;;(*compile-verbose* t)
	;;(*compile-print* t)
	)

    (format t "~&;;About to build shared library mkcl_~A.dll~%" (si:mkcl-version))
    (unless (compiler:build-shared-library (mkcl:bstr+ "mkcl_" (si:mkcl-version) ".dll")