objective-cl.asd


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

;;;; Objective-CL, an Objective-C bridge for Common Lisp.
;;;; Copyright (C) 2007  Matthias Andreas Benkard.
;;;;
;;;; 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 3 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, see
;;;; <http://www.gnu.org/licenses/>.

(defvar asdf::*objcl-version* "0.2.0")

(defsystem "objective-cl"
  :description "A portable Objective C bridge."
  :version asdf::*objcl-version*
  :author "Matthias Benkard <matthias@benkard.de>"
  :licence "GNU Lesser General Public License, version 3 or higher"
  :depends-on (#:cffi #:trivial-garbage #:split-sequence #:objective-cl-libobjcl
               #:closer-mop)
  :components
  ((:module "Lisp"
    :components ((:file "defpackage")
                 (:file "constant-data"      :depends-on ("defpackage"))
                 (:file "conditions"         :depends-on ("defpackage"))
                 (:file "parameters"         :depends-on ("defpackage"))
                 (:file "data-types"         :depends-on ("defpackage"
                                                          "conditions"))
                 (:file "internal-utilities" :depends-on ("defpackage"
                                                          "data-types"))
                 (:file "name-conversion"    :depends-on ("defpackage"
                                                          "internal-utilities"))
                 (:file "weak-hash-tables"   :depends-on ("defpackage"))
                 (:file "performance-hacks"  :depends-on ("defpackage"))
                 (:file "policy"             :depends-on ("defpackage"
                                                          "parameters"
                                                          "libobjcl"))
                 (:file "libobjcl"           :depends-on ("defpackage"
                                                          "constant-data"
                                                          "data-types"
                                                          "name-conversion"
                                                          "internal-utilities"
                                                          "parameters"
                                                          "conditions"
                                                          "memory-management"))
                 (:file "init"               :depends-on ("defpackage"
                                                          "libobjcl"))
                 (:file "type-conversion"    :depends-on ("defpackage"
                                                          "memory-management"
                                                          "data-types"
                                                          "type-handling"
                                                          "policy"
                                                          "data-types"))
                 (:file "type-conversion-policy" :depends-on ("defpackage"
                                                              "memory-management"
                                                              "data-types"
                                                              "type-handling"
                                                              "policy"
                                                              "data-types"
                                                              "method-invocation"
                                                              "lisp-value-wrapping"))
                 (:file "type-handling"      :depends-on ("defpackage"
                                                          "libobjcl"
                                                          "init"))
                 (:file "memory-management"  :depends-on ("defpackage"
                                                          "weak-hash-tables"
                                                          "parameters"
                                                          "conditions"))
                 (:file "method-invocation"  :depends-on ("defpackage"
                                                          "type-conversion"
                                                          "type-handling"
                                                          "name-conversion"
                                                          "data-types"
                                                          "libobjcl"
                                                          "internal-utilities"
                                                          "parameters"
                                                          "init"
                                                          "conditions"
                                                          "memory-management"))
                 (:file "reader-syntax"      :depends-on ("defpackage"
                                                          "method-invocation"))
                 (:file "utilities"          :depends-on ("init"
                                                          "defpackage"
                                                          "method-invocation"
                                                          "data-types"))
                 (:file "class-definition"   :depends-on ("defpackage"
                                                          "libobjcl"
                                                          "type-conversion"
                                                          "type-handling"
                                                          "data-types"
                                                          "method-definition"))
                 (:file "instance-management" :depends-on ("defpackage"
                                                           "libobjcl"
                                                           "init"
                                                           "method-invocation"))
                 (:file "compiler-macros"    :depends-on ("defpackage"
                                                          "method-invocation"
                                                          "conditions"))
                 (:file "method-definition" :depends-on ("defpackage"
                                                         "libobjcl"
                                                         "init"
                                                         "method-invocation"
                                                         "data-types"))
                 (:file "lisp-value-wrapping" :depends-on ("defpackage"
                                                           "libobjcl"
                                                           "init"
                                                           "class-definition"
                                                           "method-invocation"
                                                           "method-definition"
                                                           "reader-syntax"))
                 (:file "post-init"          :depends-on ("defpackage"
                                                          "libobjcl"
                                                          "init"
                                                          "class-definition")))))
  :serial t)