build: Allow overriding CFLAGS for python packages.
[ira/wip.git] / source / build / smb_build / config_mk.pm
1 # Samba Build System
2 # - config.mk parsing functions
3 #
4 #  Copyright (C) Stefan (metze) Metzmacher 2004
5 #  Copyright (C) Jelmer Vernooij 2005
6 #  Released under the GNU GPL
7 #
8
9 package smb_build::config_mk;
10 use smb_build::input;
11 use File::Basename;
12
13 use strict;
14
15 my $section_types = {
16         "EXT_LIB" => {
17                 "LIBS"                  => "list",
18                 "CFLAGS"                => "list",
19                 "CPPFLAGS"              => "list",
20                 "LDFLAGS"               => "list",
21                 "PC_NAME" => "string",
22                 },
23         "PYTHON" => {
24                 SWIG_FILE => "string",
25                 "PRIVATE_DEPENDENCIES"  => "list",
26                 "PUBLIC_DEPENDENCIES"   => "list",
27                 "OBJ_FILES" => "list",
28                 "ENABLE"                => "bool",
29                 "LDFLAGS"               => "list",
30                 "CFLAGS"                => "list",
31         },
32         "SUBSYSTEM" => {
33                 "OBJ_FILES"             => "list",
34
35                 "PRIVATE_DEPENDENCIES"  => "list",
36                 "PUBLIC_DEPENDENCIES"   => "list",
37
38                 "ENABLE"                => "bool",
39
40                 "MANPAGE"               => "string",
41
42                 "PUBLIC_PROTO_HEADER"   => "string",
43                 "PRIVATE_PROTO_HEADER"  => "string",
44
45                 "PUBLIC_HEADERS"        => "list",
46
47                 "CFLAGS"                => "list",
48                 "LDFLAGS"               => "list",
49                 "STANDARD_VISIBILITY"   => "string",
50                 "INIT_FUNCTION_SENTINEL" => "string"
51                 },
52         "MODULE" => {
53                 "SUBSYSTEM"             => "string",
54
55                 "INIT_FUNCTION"         => "string",
56                 "OBJ_FILES"             => "list",
57
58                 "PRIVATE_DEPENDENCIES"  => "list",
59
60                 "ALIASES" => "list",
61
62                 "ENABLE"                => "bool",
63
64                 "OUTPUT_TYPE"           => "list",
65
66                 "MANPAGE"               => "string",
67                 "PRIVATE_PROTO_HEADER"  => "string",
68
69                 "CFLAGS"                => "list"
70                 },
71         "BINARY" => {
72                 "OBJ_FILES"             => "list",
73
74                 "PRIVATE_DEPENDENCIES"  => "list",
75
76                 "ENABLE"                => "bool",
77
78                 "MANPAGE"               => "string",
79                 "INSTALLDIR"            => "string",
80                 "PRIVATE_PROTO_HEADER"  => "string",
81
82                 "CFLAGS"                => "list",
83                 "LDFLAGS"               => "list",
84                 "STANDARD_VISIBILITY"   => "string",
85
86                 "USE_HOSTCC"            => "bool"
87                 },
88         "LIBRARY" => {
89                 "VERSION"               => "string",
90                 "SO_VERSION"            => "string",
91                 "LIBRARY_REALNAME" => "string",
92
93                 "PC_NAME" => "string",
94                 
95                 "INIT_FUNCTION_TYPE"    => "string",
96                 "INIT_FUNCTION_SENTINEL" => "string",
97                 "OUTPUT_TYPE"           => "list",
98
99                 "OBJ_FILES"             => "list",
100
101                 "DESCRIPTION"           => "string",
102
103                 "PRIVATE_DEPENDENCIES"  => "list",
104                 "PUBLIC_DEPENDENCIES"   => "list",
105
106                 "ENABLE"                => "bool",
107
108                 "MANPAGE"               => "string",
109
110                 "PUBLIC_HEADERS"        => "list",
111
112                 "PUBLIC_PROTO_HEADER"   => "string",
113                 "PRIVATE_PROTO_HEADER"  => "string",
114
115                 "CFLAGS"                => "list",
116                 "LDFLAGS"               => "list",
117                 "STANDARD_VISIBILITY"   => "string"
118                 }
119 };
120
121 use vars qw(@parsed_files);
122
123 @parsed_files = ();
124
125 sub _read_config_file
126 {
127         use File::Basename;
128         use Cwd;
129
130         my $srcdir = shift;
131         my $builddir = shift;
132         my $filename = shift;
133         my @dirlist;
134
135         # We need to change our working directory because config.mk files can
136         # give shell commands as the argument to "include". These shell
137         # commands can take arguments that are relative paths and we don't have
138         # a way of sensibly rewriting these.
139         my $cwd = getcwd;
140         chomp $cwd;
141
142         if ($srcdir ne $builddir) {
143                 # Push the builddir path on the front, so we prefer builddir
144                 # to srcdir when the file exists in both.
145                 @dirlist = ($builddir, $srcdir);
146         } else {
147                 @dirlist = ($srcdir);
148         }
149
150         foreach my $d (@dirlist) {
151                 my @lines;
152                 my $basedir;
153
154                 chdir $cwd;
155                 chdir $d;
156
157                 # We need to catch the exception from open in the case where
158                 # the filename is actually a shell pipeline. Why is this
159                 # different to opening a regular file? Because this is perl!
160                 eval {
161                         open(CONFIG_MK, "./$filename");
162                         @lines = <CONFIG_MK>;
163                         close(CONFIG_MK);
164                 };
165
166                 chdir $cwd;
167                 next unless (@lines);
168
169                 # I blame abartlett for this crazy hack -- jpeach
170                 if ($filename =~ /\|$/) {
171                         $basedir = $builddir;
172                 } else {
173                         $basedir = dirname($filename);
174                         push(@parsed_files, $filename);
175                 }
176                 $basedir =~ s!^($builddir|$srcdir)[/]!!;
177                 return ($filename, $basedir, @lines);
178         }
179
180         chdir $cwd;
181         return;
182 }
183
184 ###########################################################
185 # The parsing function which parses the file
186 #
187 # $result = _parse_config_mk($input, $srcdir, $builddir, $filename)
188 #
189 # $filename -   the path of the config.mk file
190 #               which should be parsed
191 sub run_config_mk($$$$)
192 {
193         sub run_config_mk($$$$);
194         my ($input, $srcdir, $builddir, $filename) = @_;
195         my $result;
196         my $linenum = -1;
197         my $infragment = 0;
198         my $section = "GLOBAL";
199         my $makefile = "";
200
201         my $basedir;
202
203         my $parsing_file;
204         my @lines;
205
206         $ENV{builddir} = $builddir;
207         $ENV{srcdir} = $srcdir;
208
209         ($parsing_file, $basedir, @lines) =
210             _read_config_file($srcdir, $builddir, $filename);
211
212         die ("$0: can't open '$filename'")
213                 unless ($parsing_file and $basedir and @lines);
214
215         my $line = "";
216         my $prev = "";
217
218         # Emit a line that lets us match up final makefile output with the
219         # corresponding input files. The curlies are so you can match the
220         # BEGIN/END pairs in a text editor.
221         $makefile .= "# BEGIN{ $parsing_file\n";
222
223         foreach (@lines) {
224                 $linenum++;
225
226                 # lines beginning with '#' are ignored
227                 next if (/^\#.*$/);
228                 
229                 if (/^(.*)\\$/) {
230                         $prev .= $1;
231                         next;
232                 } else {
233                         $line = "$prev$_";
234                         $prev = "";
235                 }
236
237                 if ($line =~ /^\[([-a-zA-Z0-9_:]+)\][\t ]*$/) 
238                 {
239                         $section = $1;
240                         $infragment = 0;
241                         next;
242                 }
243
244                 # include
245                 if ($line =~ /^include (.*)$/) {
246                         my $subfile= $1;
247                         my $subdir = dirname($filename);
248                         $subdir =~ s/^\.$//g;
249                         $subdir =~ s/^\.\///g;
250                         $subdir .= "/" if ($subdir ne "");
251                         $makefile .= run_config_mk($input, $srcdir, $builddir, $subdir.$subfile);
252                         next;
253                 }
254
255                 # empty line
256                 if ($line =~ /^[ \t]*$/) {
257                         $section = "GLOBAL";
258                         if ($infragment) { $makefile.="\n"; }
259                         next;
260                 }
261
262                 # global stuff is considered part of the makefile
263                 if ($section eq "GLOBAL") {
264                         if (!$infragment) { $makefile.="\n"; }
265                         $makefile .= $line;
266                         $infragment = 1;
267                         next;
268                 }
269
270                 
271                 # Assignment
272                 if ($line =~ /^([a-zA-Z0-9_]+)[\t ]*=(.*)$/) {
273                         $result->{$section}{$1}{VAL} = $2;
274                         $result->{$section}{$1}{KEY} = $1;
275                 
276                         next;
277                 }
278
279                 die("$parsing_file:$linenum: Bad line while parsing $parsing_file");
280         }
281
282         $makefile .= "# }END $parsing_file\n";
283
284         foreach my $section (keys %{$result}) {
285                 my ($type, $name) = split(/::/, $section, 2);
286
287                 my $sectype = $section_types->{$type};
288                 if (not defined($sectype)) {
289                         die($parsing_file.":[".$section."] unknown section type \"".$type."\"!");
290                 }
291
292                 $input->{$name}{NAME} = $name;
293                 $input->{$name}{TYPE} = $type;
294                 $input->{$name}{MK_FILE} = $parsing_file;
295                 $input->{$name}{BASEDIR} = $basedir;
296
297                 foreach my $key (values %{$result->{$section}}) {
298                         $key->{VAL} = smb_build::input::strtrim($key->{VAL});
299                         my $vartype = $sectype->{$key->{KEY}};
300                         if (not defined($vartype)) {
301                                 die($parsing_file.":[".$section."]: unknown attribute type \"$key->{KEY}\"!");
302                         }
303                         if ($vartype eq "string") {
304                                 $input->{$name}{$key->{KEY}} = $key->{VAL};
305                         } elsif ($vartype eq "list") {
306                                 $input->{$name}{$key->{KEY}} = [smb_build::input::str2array($key->{VAL})];
307                         } elsif ($vartype eq "bool") {
308                                 if (($key->{VAL} ne "YES") and ($key->{VAL} ne "NO")) {
309                                         die("Invalid value for bool attribute $key->{KEY}: $key->{VAL} in section $section");
310                                 }
311                                 $input->{$name}{$key->{KEY}} = $key->{VAL};
312                         }
313                 }
314         }
315
316         return $makefile;
317 }
318
319 1;