Context Navigation

source: trunk/debbuild@ 95

Last change on this file since 95 was 95, checked in by kdeugau, 17 years ago

/trunk

Add support for basic %if constructs:

%if <expression>
<parse this bit of spec file>
%else
<parse this bit of spec file>
%endif

<expression> will usually be %{?macro:0}%{?!macro:1}, but the
"execute-shell-code" %(<shell code>) expansion can also be used if the
output is suitable. %else is optional. %if's should be nestable
very deeply - probably 2^{31-1 at least.}

Also includes a bugfix on the initialization of $tarballdir.

Property svn:executable set to *
Property svn:keywords set to Date Rev Author

File size: 48.8 KB

Rev	Line
[93]	1	#!/usr/bin/perl -w
[2]	2	# debbuild script
[86]	3	# Shamelessly steals interface from rpm's "rpmbuild" to create
[2]	4	# Debian packages. Please note that such packages are highly
	5	# unlikely to conform to "Debian Policy".
	6	###
	7	# SVN revision info
	8	# $Date: 2007-04-27 21:10:19 +0000 (Fri, 27 Apr 2007) $
	9	# SVN revision $Rev: 95 $
	10	# Last update by $Author: kdeugau $
	11	###
[86]	12	# Copyright 2005-2007 Kris Deugau <kdeugau@deepnet.cx>
[56]	13	#
	14	# This program is free software; you can redistribute it and/or modify
	15	# it under the terms of the GNU General Public License as published by
	16	# the Free Software Foundation; either version 2 of the License, or
	17	# (at your option) any later version.
	18	#
	19	# This program is distributed in the hope that it will be useful,
	20	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	# GNU General Public License for more details.
	23	#
	24	# You should have received a copy of the GNU General Public License
	25	# along with this program; if not, write to the Free Software
	26	# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
[2]	27
[5]	28	use strict;
[6]	29	use warnings;
[7]	30	use Fcntl; # for sysopen flags
[36]	31	use Cwd 'abs_path'; # for finding where files really are
[5]	32
[10]	33	# regex debugger
	34	#use re "debug";
	35
[3]	36	# Program flow:
	37	# -> Parse/execute "system" config/macros (if any - should be rare)
	38	# -> Parse/execute "user" config/macros (if any - my requirement is %_topdir)
	39	# -> Parse command line for options, spec file/tarball/.src.deb (NB - also accept .src.rpm)
	40
[30]	41	sub expandmacros;
	42
[2]	43	# User's prefs for dirs, environment, etc,etc,etc.
	44	# config file ~/.debmacros
	45	# Default ordered search paths for config/macros:
	46	# /usr/lib/rpm/rpmrc /usr/lib/rpm/redhat/rpmrc /etc/rpmrc ~/.rpmrc
	47	# /usr/lib/rpm/macros /usr/lib/rpm/redhat/macros /etc/rpm/macros ~/.rpmmacros
	48	# **NOTE: May be possible to (ab)use bits of debhelper
	49
	50	# Build tree
	51	# default is /usr/src/debian/{BUILD,SOURCES,SPECS,DEBS,SDEBS}
	52
[3]	53	# Globals
[77]	54	my $finalmessages = ''; # A place to stuff messages that I want printed at the very end of any processing.
[3]	55	my $specfile;
	56	my $tarball;
	57	my $srcpkg;
[7]	58	my $cmdbuildroot;
[95]	59	my $tarballdir = '%{name}-%{version}'; # We do this in case of a spec file not using %setup...
[23]	60	my %specglobals; # For %define's in specfile, among other things.
[6]	61
	62	# Initialized globals
[3]	63	my $verbosity = 0;
[4]	64	my %cmdopts = (type => '',
	65	stage => 'a',
	66	short => 'n'
	67	);
[6]	68	my $topdir = "/usr/src/debian";
[13]	69	my $buildroot = "%{_tmppath}/%{name}-%{version}-%{release}.root".int(rand(99998)+1);
[6]	70
	71	# "Constants"
[4]	72	my %targets = ('p' => 'Prep',
	73	'c' => 'Compile',
	74	'i' => 'Install',
	75	'l' => 'Verify %files',
	76	'a' => 'Build binary and source',
	77	'b' => 'Build binary',
	78	's' => 'Build source'
	79	);
[87]	80	# Ah, the joys of multiple architectures. :( Feh.
	81	# As copied from rpm
	82	my %optflags = ( 'i386' => '-O2 -g -march=i386 -mcpu=i686',
	83	'amd64' => '-O2 -g'
	84	);
	85	my $hostarch; # we set this later...
[6]	86	my $scriptletbase =
	87	q(#!/bin/sh
[3]	88
[6]	89	RPM_SOURCE_DIR="%{_topdir}/SOURCES"
	90	RPM_BUILD_DIR="%{_topdir}/BUILD"
[87]	91	RPM_OPT_FLAGS="%{optflags}"
	92	RPM_ARCH="%{_arch}"
[6]	93	RPM_OS="linux"
	94	export RPM_SOURCE_DIR RPM_BUILD_DIR RPM_OPT_FLAGS RPM_ARCH RPM_OS
	95	RPM_DOC_DIR="/usr/share/doc"
	96	export RPM_DOC_DIR
	97	RPM_PACKAGE_NAME="%{name}"
	98	RPM_PACKAGE_VERSION="%{version}"
	99	RPM_PACKAGE_RELEASE="%{release}"
	100	export RPM_PACKAGE_NAME RPM_PACKAGE_VERSION RPM_PACKAGE_RELEASE
	101	RPM_BUILD_ROOT="%{buildroot}"
	102	export RPM_BUILD_ROOT
[10]	103	);
	104	foreach (`dpkg-architecture`) {
	105	s/=(.+)/="$1"/;
	106	$scriptletbase .= " $_";
[90]	107	($hostarch) = (/^DEB_HOST_ARCH="(.+)"$/) if /DEB_HOST_ARCH=/;
[10]	108	}
	109	$scriptletbase .=
	110	q(
[6]	111	set -x
	112	umask 022
	113	cd %{_topdir}/BUILD
	114	);
	115
[5]	116	# Package data
	117	# This is the form of $pkgdata{pkgname}{meta}
	118	# meta includes Summary, Name, Version, Release, Group, Copyright,
[38]	119	# Source, URL, Packager, BuildRoot, Description, BuildReq(uires),
	120	# Requires, Provides
[6]	121	# 10/31/2005 Maybe this should be flatter? -kgd
[5]	122	my %pkgdata;
[27]	123	my @pkglist = ('main'); #sigh
[23]	124	# Files listing. Embedding this in %pkgdata would be, um, messy.
	125	my %filelist;
[40]	126	my $buildreq = '';
[5]	127
[6]	128	# Scriptlets
[48]	129	my $prepscript = '';
	130	my $buildscript = '';
[23]	131	# %install doesn't need the full treatment from %clean; just an empty place to install to.
	132	# NB - rpm doesn't do this; is it really necessary?
	133	my $installscript = '[ "$RPM_BUILD_ROOT" != "/" ] && rm -rf $RPM_BUILD_ROOT'."\n";
[48]	134	my $cleanscript = '';
[6]	135
[5]	136	die "Not enough arguments\n" if #$argv == 0;
	137
[13]	138	# Snag some environment data
	139	my $tmpdir;
	140	if (defined $ENV{TMP} && $ENV{TMP} =~ /^(\/var)?\/tmp$/) {
	141	$tmpdir = $ENV{TMP};
	142	} else {
	143	$tmpdir = "/var/tmp";
	144	}
	145
[7]	146	##main
	147
[4]	148	load_userconfig();
[3]	149	parse_cmd();
	150
[50]	151	if ($cmdopts{install}) {
	152	install_sdeb();
	153	exit 0;
	154	}
	155
[81]	156	# output stage of --showpkgs
[71]	157	if ($cmdopts{type} eq 'd') {
	158	parse_spec();
	159	foreach my $pkg (@pkglist) {
	160	$pkgdata{$pkg}{name} =~ tr/_/-/;
	161
[87]	162	my $pkgfullname = "$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb";
[71]	163
[76]	164	print "$pkgfullname\n" if $filelist{$pkg};
[79]	165
[71]	166	}
[80]	167	# Source package
[85]	168	print "$pkgdata{main}{name}-$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb\n";
[71]	169	exit 0;
	170	}
	171
[50]	172	# Stick --rebuild handling in here - basically install_sdeb()
	173	# followed by tweaking options to run with -ba
[54]	174	if ($cmdopts{type} eq 's') {
[55]	175	if ($srcpkg =~ /\.src\.rpm$/) {
[58]	176	my @srclist = qx { rpm -qlp $srcpkg };
[55]	177	foreach (@srclist) {
[54]	178	chomp;
[55]	179	$specfile = "$topdir/SPECS/$_" if /\.spec$/;
[54]	180	}
[55]	181	qx { rpm -i $srcpkg };
	182	} else {
	183	install_sdeb();
	184	my @srclist = qx { pax < $srcpkg };
	185	foreach (@srclist) {
	186	chomp;
	187	$specfile = "$topdir/$_" if /SPECS/;
	188	}
[54]	189	}
[55]	190	$cmdopts{type} = 'b';
	191	$cmdopts{stage} = 'a';
[54]	192	}
[50]	193
[7]	194	if ($cmdopts{type} eq 'b') {
	195	# Need to read the spec file to find the tarball. Note that
	196	# this also generates most of the shell script required.
	197	parse_spec();
[38]	198	die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
	199	if !checkbuildreq();
[7]	200	}
	201
[65]	202	if ($cmdopts{type} eq 't') {
	203	# Need to unpack the tarball to find the spec file. Sort of the inverse of -b above.
	204	# zcat $tarball \|tar -t \|grep .spec
	205	# collect some info about the tarball
	206	$specfile = "$topdir/BUILD/". qx { zcat $tarball \|tar -t \|grep .spec\$ };
	207	chomp $specfile;
	208	my ($fileonly, $dirname) = ($tarball =~ /(([a-zA-Z0-9._-]+)\.tar\.(?:gz\|bz2))$/);
	209
	210	$tarball = abs_path($tarball);
	211	my $unpackcmd = "cd $topdir/BUILD; tar -".
	212	( $tarball =~ /\.tar\.gz$/ ? "z" : "" ).
	213	( $tarball =~ /\.tar\.bz2$/ ? "j" : "" ). "xf $tarball";
	214	system "$unpackcmd";
	215	system "cp $tarball $topdir/SOURCES/$fileonly";
	216	system "cp $specfile $topdir/SPECS/";
	217	parse_spec();
	218	die "Can't build $pkgdata{main}{name}: build requirements not met.\n"
	219	if !checkbuildreq();
	220	}
	221
[35]	222	# -> srcpkg if -.s
	223	if ($cmdopts{stage} eq 's') {
	224	srcpackage();
	225	exit 0;
	226	}
	227
[4]	228	# Hokay. Need to:
[14]	229	# -> prep if -.p OR (-.[cilabs] AND !--short-circuit)
[7]	230	if ($cmdopts{stage} eq 'p' \|\| ($cmdopts{stage} =~ /[cilabs]/ && $cmdopts{short} ne 'y')) {
	231	prep();
	232	}
[14]	233	# -> build if -.c OR (-.[ilabs] AND !--short-circuit)
[7]	234	if ($cmdopts{stage} eq 'c' \|\| ($cmdopts{stage} =~ /[ilabs]/ && $cmdopts{short} ne 'y')) {
	235	build();
	236	}
[14]	237	# -> install if -.[ilabs]
[28]	238	#if ($cmdopts{stage} eq 'i' \|\| ($cmdopts{stage} =~ /[labs]/ && $cmdopts{short} ne 'y')) {
	239	if ($cmdopts{stage} =~ /[ilabs]/) {
[7]	240	install();
[30]	241	#foreach my $pkg (@pkglist) {
	242	# print "files in $pkg:\n ".$filelist{$pkg}."\n";
	243	#}
	244
[7]	245	}
[14]	246	# -> binpkg and srcpkg if -.a
[7]	247	if ($cmdopts{stage} eq 'a') {
[4]	248	binpackage();
[7]	249	srcpackage();
[4]	250	}
[14]	251	# -> binpkg if -.b
[7]	252	if ($cmdopts{stage} eq 'b') {
	253	binpackage();
	254	}
[4]	255
[77]	256	# Spit out any closing remarks
	257	print $finalmessages;
	258
[4]	259	# Just in case.
	260	exit 0;
	261
	262
	263	## load_userconfig()
	264	# Loads user configuration (if any)
	265	# Currently only handles .debmacros
	266	# Needs to handle "other files"
	267	sub load_userconfig {
[5]	268	my (undef,undef,undef,undef,undef,undef,undef,$homedir,undef) = getpwuid($<);
[4]	269	if (-e "$homedir/.debmacros") {
	270	open USERMACROS,"<$homedir/.debmacros";
	271	while (<USERMACROS>) {
[7]	272	# And we also only handle a few macros at the moment.
[4]	273	if (/^\%_topdir/) {
[5]	274	my (undef,$tmp) = split /\s+/, $_;
	275	$topdir = $tmp;
[4]	276	}
	277	}
	278	}
	279	} # end load_userconfig()
	280
	281
[3]	282	## parse_cmd()
[4]	283	# Parses command line into global hash %cmdopts, other globals
[3]	284	# Options based on rpmbuild's options
	285	sub parse_cmd {
	286	# Don't feel like coding my own option parser...
	287	#use Getopt::Long;
	288	# ... but I may have to: (OTOH, rpm uses popt, so maybe we can too.)
	289	#use Getopt::Popt qw(:all);
[4]	290	# Or not. >:( Stupid Debian lack of findable Perl module names in packages.
[3]	291
	292	# Stuff it.
[4]	293	my $prevopt = '';
[3]	294	foreach (@ARGV) {
	295	chomp;
[7]	296
[3]	297	# Is it an option?
	298	if (/^-/) {
[7]	299
[3]	300	# Is it a long option?
	301	if (/^--/) {
[4]	302	if (/^--short-circuit/) {
	303	$cmdopts{short} = 'y';
[5]	304	} elsif (/^--rebuild/) {
	305	$cmdopts{type} = 's';
[71]	306	} elsif (/^--showpkgs/) {
	307	$cmdopts{type} = 'd'; # d for 'diagnostic' or 'debug' or 'dump'
[94]	308	} elsif (/^--define/) {
	309	# nothing to do? Can't see anything needed, we handle the actual definition later.
[4]	310	} else {
[93]	311	print "Long option $_ not handled\n";
[4]	312	}
[3]	313	} else {
[14]	314	# Not a long option
[5]	315	if (/^-[bt]/) {
	316	if ($cmdopts{stage} eq 's') {
	317	# Mutually exclusive options.
	318	die "Can't use $_ with --rebuild\n";
	319	} else {
[14]	320	# Capture the type (from "bare" files or tarball) and the stage (prep, build, etc)
[5]	321	($cmdopts{stage}) = (/^-[bt]([pcilabs])/);
	322	($cmdopts{type}) = (/^-([bt])[pcilabs]/);
	323	}
[4]	324	} elsif (/^-v/) {
	325	# bump verbosity. Not sure what I'll actually do here...
[50]	326	} elsif (/^-i/) {
	327	$cmdopts{install} = 1;
	328	$prevopt = '-i';
[4]	329	} else {
	330	die "Bad option $_\n";
	331	}
[3]	332	}
[14]	333
	334	} else { # Not an option argument
	335
[5]	336	# --buildroot is the only option that takes an argument
	337	# Therefore, any other bare arguments are the spec file,
	338	# tarball, or source package we're operating on - depending
	339	# on which one we meet.
	340	if ($prevopt eq '--buildroot') {
[7]	341	$cmdbuildroot = $_;
[94]	342	} elsif ($prevopt eq '--define') {
	343	my ($macro,$value) = (/([a-z0-9_.-]+)(?:\s+(.+))?/);
	344	if ($value) {
	345	$specglobals{$macro} = $value;
	346	} else {
	347	warn "WARNING: missing value for macro $macro in --define! Ignoring.\n";
	348	}
[50]	349	} elsif ($prevopt eq '-i') {
	350	$srcpkg = $_;
[5]	351	} else {
	352	if ($cmdopts{type} eq 's') {
	353	# Source package
[50]	354	if (!/(sdeb\|\.src\.rpm)$/) {
[5]	355	die "Can't --rebuild with $_\n";
	356	}
[50]	357	$srcpkg = $_;
[71]	358	} elsif ($cmdopts{type} eq 'b' \|\| $cmdopts{type} eq 'd') {
[65]	359	# Spec file
[5]	360	$specfile = $_;
	361	} else {
[65]	362	# Tarball build. Need to extract tarball to find spec file. Whee.
	363	$tarball = $_;
[5]	364	}
	365	}
[3]	366	}
[7]	367	$prevopt = $_;
	368	} # foreach @ARGV
[4]	369
	370	# Some cross-checks. rpmbuild limits --short-circuit to just
	371	# the "compile" and "install" targets - with good reason IMO.
[14]	372	# Note that --short-circuit with -.p is not really an error, just redundant.
[4]	373	# NB - this is NOT fatal, just ignored!
[10]	374	if ($cmdopts{short} eq 'y' && $cmdopts{stage} =~ /[labs]/) {
[4]	375	warn "Can't use --short-circuit for $targets{$cmdopts{stage}} stage. Ignoring.\n";
[28]	376	$cmdopts{short} = 'n';
[4]	377	}
[14]	378
[3]	379	# Valid options, with example arguments (if any):
	380	# Build from .spec file; mutually exclusive:
	381	# -bp
	382	# -bc
	383	# -bi
	384	# -bl
	385	# -ba
	386	# -bb
	387	# -bs
	388	# Build from tarball; mutually exclusive:
	389	# -tp
	390	# -tc
	391	# -ti
	392	# -ta
	393	# -tb
	394	# -ts
	395	# Build from .src.(deb\|rpm)
	396	# --rebuild
	397	# --recompile
	398
	399	# General options
	400	# --buildroot=DIRECTORY
	401	# --clean
	402	# --nobuild
	403	# --nodeps
	404	# --nodirtokens
	405	# --rmsource
	406	# --rmspec
	407	# --short-circuit
	408	# --target=CPU-VENDOR-OS
	409
	410	#my $popt = new Getopt::Popt(argv => \@ARGV, options => \@optionsTable);
	411
	412	} # end parse_cmd()
	413
[4]	414
[5]	415	## parse_spec()
[14]	416	# Parse the .spec file.
[5]	417	sub parse_spec {
[65]	418	open SPECFILE,"<$specfile" or die "specfile ($specfile) barfed: $!";
[5]	419
[95]	420	my $iflevel = 0;
[87]	421	my $buildarch = $hostarch;
[88]	422	$pkgdata{main}{arch} = $hostarch;
[87]	423
[6]	424	LINE: while (<SPECFILE>) {
[14]	425	next if /^#/; # Ignore comments...
[93]	426	next if /^\s*$/; # ... and blank lines.
[14]	427
[5]	428	if (/^\%/) {
	429	# A macro that needs further processing.
[14]	430
[60]	431	if (my ($key, $def) = (/^\%define\s+([^\s]+)\s+(.+)$/) ) {
	432	$specglobals{$key} = expandmacros($def,'g');
[23]	433	}
	434
[95]	435	if (/^\%if/) {
	436	s/^\%if//;
	437	my $expr = expandmacros($_, 'g');
	438	$iflevel++;
	439	next LINE if $expr != 0; # This appears to be the only case we call false.
	440	while (<SPECFILE>) {
	441	if (/^\%endif/) {
	442	$iflevel--;
	443	next LINE;
	444	} elsif (/^\%else/) {
	445	next LINE;
	446	}
	447	}
	448	}
	449	if (/^\%else/) {
	450	while (<SPECFILE>) {
	451	if (/^\%endif/) {
	452	$iflevel--;
	453	next LINE;
	454	}
	455	}
	456	}
	457	if (/^\%endif/) {
	458	$iflevel--;
	459	next LINE;
	460	}
	461
[62]	462	if (/^\%description(?:\s+(?:-n\s+)?(.+))?/) {
[27]	463	my $subname = "main";
	464	if ($1) {
[62]	465	my $tmp = expandmacros("$1", 'g');
[49]	466	if (/-n/) { $subname = $tmp; } else { $subname = "$pkgdata{main}{name}-$tmp"; }
[27]	467	}
[8]	468	while (<SPECFILE>) {
[39]	469	next if /^#/; # Messy. Should be possible to do better. :/
[8]	470	redo LINE if /^\%/;
[27]	471	$pkgdata{$subname}{desc} .= " $_";
[8]	472	}
[18]	473	}
[62]	474	if (/^\%package\s+(?:-n\s+)?(.+)/) {
	475	# gotta expand %defines here. Whee.
	476	my $subname = expandmacros("$1", 'g');
[49]	477	if (! /-n/) { $subname = "$pkgdata{main}{name}-$1"; }
[27]	478	push @pkglist, $subname;
	479	$pkgdata{$subname}{name} = $subname;
	480	$pkgdata{$subname}{version} = $pkgdata{main}{version};
[87]	481	# Build "same arch as previous package found" by default. Where rpm just picks the
	482	# very last one, we want to allow arch<native>+arch-all
	483	# (eg, Apache is i386, but apache-manual is all)
	484	$pkgdata{$subname}{arch} = $buildarch; # Since it's likely subpackages will NOT have a BuildArch line...
[27]	485	while (<SPECFILE>) {
	486	redo LINE if /^\%/;
[87]	487	if (my ($dname,$dvalue) = (/^(Summary\|Group\|Version\|Requires\|Provides\|BuildArch(?:itecture)?):\s+(.+)$/i)) {
[27]	488	$dname =~ tr/[A-Z]/[a-z]/;
[87]	489	if ($dname =~ /^BuildArch/i) {
[91]	490	$dvalue =~ s/^noarch/all/ig;
[87]	491	$buildarch = $dvalue; # Emulate rpm's behaviour to a degree
	492	$dname = 'arch';
	493	}
[63]	494	$pkgdata{$subname}{$dname} = expandmacros($dvalue, 'gp');
[27]	495	}
	496	}
	497	}
[8]	498
[6]	499	if (/^\%prep/) {
	500	# %prep section. May have %setup macro; may include %patch tags,
	501	# may be just a bare shell script.
	502
	503	# This really should be local-ish, but we need just the filename for the source
	504	$pkgdata{main}{source} =~ s\|.+/([^/]+)$\|$1\|;
	505
	506	# Replace some core macros
[14]	507	$pkgdata{main}{source} = expandmacros($pkgdata{main}{source},'gp');
[6]	508
	509	PREPSCRIPT: while (<SPECFILE>) {
	510	if (/^\%setup/) {
	511	# Parse out the %setup macro. Note that we aren't supporting
[14]	512	# many of RPM's %setup features.
[7]	513	$prepscript .= "cd $topdir/BUILD\n";
	514	if ( /\s+-n\s+([^\s]+)\s+/ ) {
	515	$tarballdir = $1;
	516	}
[69]	517	$tarballdir = expandmacros($tarballdir,'gp');
	518	$prepscript .= "rm -rf $tarballdir\n";
	519	if (/\s+-c\s+/) {
	520	$prepscript .= "mkdir $tarballdir\ncd $tarballdir\n";
	521	}
	522	$prepscript .= "tar -".
[6]	523	( $pkgdata{main}{source} =~ /\.tar\.gz$/ ? "z" : "" ).
	524	( $pkgdata{main}{source} =~ /\.tar\.bz2$/ ? "j" : "" ).
[21]	525	( /\s+-q\s+/ ? '' : 'vv' )."xf ".
	526	"$topdir/SOURCES/$pkgdata{main}{source}\n".
[6]	527	qq(STATUS=\$?\nif [ \$STATUS -ne 0 ]; then\n exit \$STATUS\nfi\n).
[69]	528	"cd $topdir/BUILD/$tarballdir\n".
[6]	529	qq([ `/usr/bin/id -u` = '0' ] && /bin/chown -Rhf root .\n).
	530	qq([ `/usr/bin/id -u` = '0' ] && /bin/chgrp -Rhf root .\n).
	531	qq(/bin/chmod -Rf a+rX,g-w,o-w .\n);
[67]	532	} elsif ( my ($patchnum,$patchopts) = (/^\%patch([^\s]+)(\s+.+)?$/) ) {
	533	chomp $patchnum;
[70]	534	$prepscript .= qq(echo "Patch #$patchnum ($pkgdata{main}{"patch$patchnum"}):"\n).
	535	"patch ";
	536	# If there are options passed, use'em.
	537	# Otherwise, catch a bare %patch and ASS-U-ME it's '-p0'-able.
	538	# Will break on options that don't provide -pnn, but what the hell.
[66]	539	$prepscript .= $patchopts if $patchopts;
[70]	540	$prepscript .= "-p0" if !$patchopts;
	541	$prepscript .= " -s <$topdir/SOURCES/".$pkgdata{main}{"patch$patchnum"}."\n";
[6]	542	} else {
	543	last PREPSCRIPT if /^\%/;
	544	$prepscript .= $_;
	545	}
	546	}
	547	redo LINE;
	548	}
[12]	549	if (/^\%build/) {
[6]	550	# %build. This is pretty much just a shell script. There
	551	# are a few macros, but we're not going to deal with them yet.
[7]	552	$buildscript .= "cd $tarballdir\n";
[10]	553	BUILDSCRIPT: while (<SPECFILE>) {
	554	if (/^\%configure/) {
[12]	555	$buildscript .= expandmacros($_,'cgbp');
[25]	556	} elsif (/^\%\{__make\}/) {
[12]	557	$buildscript .= expandmacros($_,'mgbp');
[10]	558	} else {
[24]	559	last BUILDSCRIPT if /^\%[^{]/;
[10]	560	$buildscript .= $_;
	561	}
[6]	562	}
[10]	563	redo LINE;
[5]	564	}
[6]	565	if (/^\%install/) {
[7]	566	$installscript .= "cd $tarballdir\n";
[12]	567	INSTALLSCRIPT: while (<SPECFILE>) {
	568	if (/^\%makeinstall/) {
	569	$installscript .= expandmacros($_,'igbp');
	570	} else {
	571	last INSTALLSCRIPT if /^\%/;
	572	$installscript .= $_;
	573	}
	574	}
	575	redo LINE;
[6]	576	}
	577	if (/^\%clean/) {
[7]	578	while (<SPECFILE>) {
	579	redo LINE if /^\%/;
	580	$cleanscript .= $_;
	581	}
[12]	582	$cleanscript = expandmacros($cleanscript,'gp');
[6]	583	}
[29]	584
[75]	585	# pre/post (un)install scripts. Note that we expand macros later anyway, so we'll leave them unexpanded here.
	586	if (/^\%(pre\|post\|preun\|postun)\b(?:\s+(?:-n\s+)?(.+))?/i) {
	587	my $scriptlet = lc $1;
	588	my $pkgname = 'main';
	589	if ($2) { # Magic to add entries to the right list of files
	590	my $tmp = expandmacros("$2", 'g');
	591	if (/-n/) { $pkgname = $tmp; } else { $pkgname = "$pkgdata{main}{name}-$tmp"; }
[16]	592	}
	593	while (<SPECFILE>) {
	594	redo LINE if /^\%/;
[75]	595	$pkgdata{$pkgname}{$scriptlet} .= $_;
[16]	596	}
[6]	597	}
[29]	598	# done %pre/%post scripts
	599
[62]	600	if (/^\%files(?:\s+(?:-n\s+)?(.+))?/) {
[23]	601	my $pkgname = 'main';
[29]	602	if ($1) { # Magic to add entries to the right list of files
[62]	603	my $tmp = expandmacros("$1", 'g');
[49]	604	if (/-n/) { $pkgname = $tmp; } else { $pkgname = "$pkgdata{main}{name}-$tmp"; }
[23]	605	}
[37]	606
	607	# Set this now, so it can be flipped a bit later, and used much later.
	608	#$pkgdata{$pkgname}{conffiles} = 0;
	609
[27]	610	while (<SPECFILE>) {
[29]	611	chomp;
[45]	612	next if /^#/;
[29]	613	# need to update this to deal (properly) with %dir, %attr, etc
	614	next if /^\%dir/;
	615	next if /^\%defattr/;
	616
[37]	617	# Debian dpkg doesn't speak "%docdir". Meh.
	618	next if /^\%docdir/;
	619
[76]	620	##fixme
	621	# Note that big chunks of this section don't match rpm's behaviour; among other things,
	622	# rpm accepts more than one %-directive on one line for a file or set of files.
	623	# make sure files get suitable permissions and so on
	624	if (/^\%attr/) {
	625	# We're going to collapse whitespace before processing. PTHBT.
	626	# While this breaks pathnames with spaces, anyone expecting command-line
	627	# tools with spaces to work (never mind work properly or well) under
	628	# any *nix has their head so far up their ass they can see out their mouth.
	629	my ($args,$filelist) = split /\)/;
	630	$filelist{$pkgname} .= " $filelist";
	631	$args =~ s/\s+//g;
	632	$args =~ s/"//g; # don't think quotes are ever necessary, but they're allowed
[83]	633	my ($perms,$owner,$group) = ($args =~ /\(([\d-]+),([a-zA-Z0-9-]+),([a-zA-Z0-9-]+)/);
[76]	634	# due to Debian's total lack of real permissions-processing in its actual package
	635	# handling component (dpkg-deb), this can't really be done "properly". We'll have
	636	# to add chown/chmod commands to the postinst instead. Feh.
	637	$pkgdata{$pkgname}{'post'} .= "chown $owner $filelist\n" if $owner ne '-';
	638	$pkgdata{$pkgname}{'post'} .= "chgrp $group $filelist\n" if $group ne '-';
[78]	639	$pkgdata{$pkgname}{'post'} .= "chmod $perms $filelist\n" if $perms ne '-';
[82]	640	next;
[76]	641	}
	642
[72]	643	# %doc needs extra processing, because it can be a space-separated list.
	644	if (/^\%doc/) {
	645	s/^\%doc\s+//;
	646	foreach (split()) {
	647	$filelist{$pkgname} .= " %{_docdir}/$_";
	648	}
	649	next;
	650	}
	651
[37]	652	# Conffiles. Note that Debian and RH have similar, but not
	653	# quite identical ideas of what constitutes a conffile. Nrgh.
	654	if (/^\%config\s+(.+)$/) {
	655	$pkgdata{$pkgname}{conffiles} = 1; # Flag it for later
	656	my $tmp = $1; # Now we can mangleificationate it. And we probably need to. :/
[46]	657	$tmp = expandmacros($tmp, 'gp'); # Expand common macros
[37]	658	if ($tmp !~ /\s+/) {
	659	# Simplest case, just a file. Whew.
	660	push @{$pkgdata{$pkgname}{conflist}}, $tmp;
	661	$filelist{$pkgname} .= " $tmp";
	662	} else {
	663	# Wot? Spaces? That means extra %-macros. Which, for the most part, can be ignored.
	664	($tmp) = ($tmp =~ /.+\s([^\s]+)/); # Strip everything before the last space
	665	push @{$pkgdata{$pkgname}{conflist}}, $tmp;
	666	$filelist{$pkgname} .= " $tmp";
	667	}
	668	next;
	669	}
	670
[29]	671	# and finally we can fall through %{_<FHS>}-prefixed locations...
[30]	672	if (/^\%\{_/) {
	673	$filelist{$pkgname} .= " $_";
	674	next;
	675	}
	676	# EW. Necessary to clear up %define expansions before we exit with redo.
	677	$_ = expandmacros $_, 'g';
[29]	678
	679	# ... unknown or "next section" % directives ...
[27]	680	redo LINE if /^\%/;
[29]	681
	682	# ... and "normal" files
[27]	683	$filelist{$pkgname} .= " $_";
	684	}
[29]	685	} # done %file section
	686
[18]	687	if (/^\%changelog/) {
	688	$pkgdata{main}{changelog} = '';
	689	while (<SPECFILE>) {
	690	redo LINE if /^\%/;
	691	$pkgdata{main}{changelog} .= $_;
	692	}
	693	}
[93]	694	# don't add any segments after this (%changelog), because something in the (Perl) parser gets
	695	# thoroughly confuzzled if it tries to manipulate file data after EOL. Feh.
[14]	696
	697	} else { # Data from the spec file "header"
	698
[5]	699	if (/^summary:\s+(.+)/i) {
	700	$pkgdata{main}{summary} = $1;
	701	} elsif (/^name:\s+(.+)/i) {
[24]	702	$pkgdata{main}{name} = expandmacros($1,'g');
[5]	703	} elsif (/^version:\s+(.+)/i) {
[24]	704	$pkgdata{main}{version} = expandmacros($1,'g');
[5]	705	} elsif (/^release:\s+(.+)/i) {
[24]	706	$pkgdata{main}{release} = expandmacros($1,'g');
[5]	707	} elsif (/^group:\s+(.+)/i) {
	708	$pkgdata{main}{group} = $1;
	709	} elsif (/^copyright:\s+(.+)/i) {
	710	$pkgdata{main}{copyright} = $1;
	711	} elsif (/^url:\s+(.+)/i) {
	712	$pkgdata{main}{url} = $1;
	713	} elsif (/^packager:\s+(.+)/i) {
	714	$pkgdata{main}{packager} = $1;
[7]	715	} elsif (/^buildroot:\s+(.+)/i) {
	716	$buildroot = $1;
[59]	717	} elsif (/^source0?:\s+(.+)/i) {
[5]	718	$pkgdata{main}{source} = $1;
[6]	719	die "Unknown tarball format $1\n" if $1 !~ /\.tar\.(?:gz\|bz2)$/;
[15]	720	} elsif (/^source([0-9]+):\s+(.+)/i) {
	721	$pkgdata{sources}{$1} = $2;
[10]	722	} elsif (/^patch([^:]+):\s+(.+)$/i) {
[26]	723	my $patchname = "patch$1";
	724	$pkgdata{main}{$patchname} = $2;
	725	if ($pkgdata{main}{$patchname} =~ /\//) {
	726	# URL-style patch. Rare but not unheard-of.
	727	my @patchbits = split '/', $pkgdata{main}{$patchname};
	728	$pkgdata{main}{$patchname} = $patchbits[$#patchbits];
	729	}
[66]	730	chomp $pkgdata{main}{$patchname};
[87]	731	} elsif (/^buildarch(?:itecture)?:\s+(.+)/i) {
	732	$pkgdata{main}{arch} = $1;
[91]	733	$pkgdata{main}{arch} =~ s/^noarch$/all/;
[87]	734	$buildarch = $pkgdata{main}{arch};
[38]	735	} elsif (/^buildreq(?:uires)?:\s+(.+)/i) {
	736	$buildreq .= ", $1";
	737	} elsif (/^requires:\s+(.+)/i) {
[63]	738	$pkgdata{main}{requires} .= ", ".expandmacros("$1", 'gp');
[38]	739	} elsif (/^provides:\s+(.+)/i) {
	740	$pkgdata{main}{provides} .= ", $1";
[51]	741	} elsif (/^conflicts:\s+(.+)/i) {
	742	$pkgdata{main}{conflicts} .= ", $1";
[5]	743	}
	744	#Name: suwrap
	745	#Version: 0.04
	746	#Release: 3
	747	#Group: Applications/System
	748	#Copyright: WebHart internal ONLY. :(
	749	#BuildArchitectures: i386
	750	#BuildRoot: /tmp/%{name}-%{version}
	751	#Url: http://virtual.webhart.net
	752	#Packager: Kris Deugau <kdeugau@deepnet.cx>
	753	#Source: ftp://virtual.webhart.net/%{name}-%{version}.tar.gz
	754
	755	}
	756	}
[7]	757
[14]	758	# Parse and replace some more macros. More will be replaced even later.
	759
[10]	760	# Expand macros as necessary.
[12]	761	$scriptletbase = expandmacros($scriptletbase,'gp');
[7]	762
	763	$buildroot = $cmdbuildroot if $cmdbuildroot;
[12]	764	$buildroot = expandmacros($buildroot,'gp');
[7]	765
[16]	766	close SPECFILE;
[5]	767	} # end parse_spec()
	768
	769
[7]	770	## prep()
[14]	771	# Writes and executes the %prep script (mostly) built while reading the spec file.
[7]	772	sub prep {
[10]	773	# Replace some things here just to make sure.
[12]	774	$prepscript = expandmacros($prepscript,'gp');
[10]	775
	776	# create script filename
[13]	777	my $prepscriptfile = "$tmpdir/deb-tmp.prep.".int(rand(99998)+1);
[10]	778	sysopen(PREPSCRIPT, $prepscriptfile, O_RDWR \| O_CREAT \| O_EXCL \| O_NOFOLLOW)
[7]	779	or die $!;
[10]	780	print PREPSCRIPT $scriptletbase;
	781	print PREPSCRIPT $prepscript;
	782	close PREPSCRIPT;
[7]	783
[10]	784	# execute
	785	print "Calling \%prep script $prepscriptfile...\n";
	786	system("/bin/sh -e $prepscriptfile") == 0
[14]	787	or die "Can't exec: $!\n";
[7]	788
[10]	789	# and clean up
	790	unlink $prepscriptfile;
[7]	791	} # end prep()
	792
	793
[5]	794	## build()
[14]	795	# Writes and executes the %build script (mostly) built while reading the spec file.
[5]	796	sub build {
[12]	797	# Expand the macros
	798	$buildscript = expandmacros($buildscript,'cgbp');
	799
[7]	800	# create script filename
[13]	801	my $buildscriptfile = "$tmpdir/deb-tmp.build.".int(rand(99998)+1);
[7]	802	sysopen(BUILDSCRIPT, $buildscriptfile, O_RDWR \| O_CREAT \| O_EXCL \| O_NOFOLLOW)
	803	or die $!;
	804	print BUILDSCRIPT $scriptletbase;
	805	print BUILDSCRIPT $buildscript;
	806	close BUILDSCRIPT;
	807
	808	# execute
	809	print "Calling \%build script $buildscriptfile...\n";
	810	system("/bin/sh -e $buildscriptfile") == 0
[14]	811	or die "Can't exec: $!\n";
[7]	812
	813	# and clean up
	814	unlink $buildscriptfile;
[5]	815	} # end build()
	816
	817
[7]	818	## install()
[14]	819	# Writes and executes the %install script (mostly) built while reading the spec file.
[7]	820	sub install {
[12]	821	# Expand the macros
	822	$installscript = expandmacros($installscript,'igbp');
	823
[7]	824	# create script filename
[13]	825	my $installscriptfile = "$tmpdir/deb-tmp.inst.".int(rand(99998)+1);
[7]	826	sysopen(INSTSCRIPT, $installscriptfile, O_RDWR \| O_CREAT \| O_EXCL \| O_NOFOLLOW)
	827	or die $!;
	828	print INSTSCRIPT $scriptletbase;
	829	print INSTSCRIPT $installscript;
	830	close INSTSCRIPT;
	831
	832	# execute
	833	print "Calling \%install script $installscriptfile...\n";
	834	system("/bin/sh -e $installscriptfile") == 0
[14]	835	or die "Can't exec: $!\n";
[7]	836
	837	# and clean up
	838	unlink $installscriptfile;
	839	} # end install()
	840
	841
[8]	842	## binpackage()
	843	# Creates the binary .deb package from the installed tree in $buildroot.
[14]	844	# Writes and executes a shell script to do so.
	845	# Creates miscellaneous files required by dpkg-deb to actually build the package file.
[27]	846	# Should handle simple subpackages
[8]	847	sub binpackage {
[14]	848
[27]	849	foreach my $pkg (@pkglist) {
[8]	850
[87]	851	$pkgdata{$pkg}{arch} = $hostarch if !$pkgdata{$pkg}{arch}; # Just In Case.
	852
	853	# Make sure we have somewhere to write the .deb file
	854	if (!-e "$topdir/DEBS/$pkgdata{$pkg}{arch}") {
	855	mkdir "$topdir/DEBS/$pkgdata{$pkg}{arch}";
	856	}
	857
[73]	858	# Skip building a package if it doesn't actually have any files. NB: This
	859	# differs slightly from rpm's behaviour where a package will be built -
	860	# even without any files - if %files is specified anywhere. I can think
	861	# of odd corner cases where that may be desireable.
[74]	862	next if (!$filelist{$pkg} or $filelist{$pkg} =~ /^\s*$/);
[73]	863
[27]	864	# Gotta do this first, otherwise we don't have a place to move files from %files
	865	mkdir "$buildroot/$pkg";
[28]	866
[30]	867	# Eliminate any lingering % macros
	868	$filelist{$pkg} = expandmacros $filelist{$pkg}, 'g';
	869
[27]	870	my @pkgfilelist = split ' ', $filelist{$pkg};
	871	foreach my $pkgfile (@pkgfilelist) {
[37]	872	$pkgfile = expandmacros($pkgfile, 'gp');
[44]	873	my ($fpath,$fname) = ($pkgfile =~ m\|(.+?/?)?([^/]+)$\|); # We don't need $fname now, but we might.
	874	qx { mkdir -p $buildroot/$pkg$fpath }
	875	if $fpath && $fpath ne '';
	876	qx { mv $buildroot$pkgfile $buildroot/$pkg$fpath };
[27]	877	}
[28]	878
[38]	879	# Get the "Depends" (Requires) a la RPM. Ish. We strip the leading
	880	# comma and space here (if needed) in case there were "Requires" specified
	881	# in the spec file - those would precede these.
[64]	882	$pkgdata{$pkg}{requires} .= getreqs("$buildroot/$pkg");
[38]	883
[64]	884	# magic needed to properly version dependencies...
	885	# only provided deps will really be included
[65]	886	$pkgdata{$pkg}{requires} =~ s/^, //; # Still have to do this here.
[64]	887	$pkgdata{$pkg}{requires} =~ s/\s+//g;
	888	my @deps = split /,/, $pkgdata{$pkg}{requires};
	889	my $tmp = '';
	890	foreach my $dep (@deps) {
[68]	891	# Hack up the perl(Class::SubClass) deps into something dpkg can understand.
	892	# May or may not be versioned.
	893	# We do this first so the version rewriter can do its magic next.
	894	if (my ($mod,$ver) = ($dep =~ /^perl\(([A-Za-z0-9\:\-]+)\)([><=]+.+)?/) ) {
	895	$mod =~ s/^perl\(//;
	896	$mod =~ s/\)$//;
	897	$mod =~ s/::/-/g;
	898	$mod =~ tr/A-Z/a-z/;
	899	$mod = "lib$mod-perl";
	900	$mod .= $ver if $ver;
	901	$dep = $mod;
	902	}
[64]	903	if (my ($name,$rel,$value) = ($dep =~ /^([a-zA-Z0-9._-]+)([><=]+)([a-zA-Z0-9._-]+)$/)) {
	904	$tmp .= ", $name ($rel $value)";
	905	} else {
	906	$tmp .= ", $dep";
	907	}
	908	}
	909	($pkgdata{$pkg}{requires} = $tmp) =~ s/^, //;
	910
[38]	911	# Do this here since we're doing {depends}...
[41]	912	if (defined($pkgdata{$pkg}{provides})) {
	913	$pkgdata{$pkg}{provides} =~ s/^, //;
	914	$pkgdata{$pkg}{provides} = expandmacros($pkgdata{$pkg}{provides},'gp');
	915	}
[51]	916	if (defined($pkgdata{$pkg}{conflicts})) {
	917	$pkgdata{$pkg}{conflicts} =~ s/^, //;
	918	$pkgdata{$pkg}{conflicts} = expandmacros($pkgdata{$pkg}{conflicts},'gp');
	919	}
[38]	920
[27]	921	# Gotta do this next, otherwise the control file has nowhere to go. >:(
	922	mkdir "$buildroot/$pkg/DEBIAN";
	923
[33]	924	# Hack the filename for the package into a Debian-tool-compatible format. GRRRRRR!!!!!
	925	# Have I mentioned I hate Debian Policy?
	926	$pkgdata{$pkg}{name} =~ tr/_/-/;
	927
[27]	928	# create script filename
	929	my $debscriptfile = "$tmpdir/deb-tmp.pkg.".int(rand(99998)+1);
	930	sysopen(DEBSCRIPT, $debscriptfile, O_RDWR \| O_CREAT \| O_EXCL \| O_NOFOLLOW)
[8]	931	or die $!;
[27]	932	print DEBSCRIPT $scriptletbase;
[87]	933	print DEBSCRIPT "fakeroot dpkg-deb -b $buildroot/$pkg $topdir/DEBS/$pkgdata{$pkg}{arch}/".
	934	"$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb\n";
[27]	935	# %$&$%@#@@#%@@@ Debian and their horrible ugly package names. >:(
	936	close DEBSCRIPT;
[8]	937
[27]	938	my $control = "Package: $pkgdata{$pkg}{name}\n".
	939	"Version: $pkgdata{$pkg}{version}-$pkgdata{main}{release}\n".
	940	"Section: $pkgdata{$pkg}{group}\n".
[8]	941	"Priority: optional\n".
[87]	942	"Architecture: $pkgdata{$pkg}{arch}\n".
[8]	943	"Maintainer: $pkgdata{main}{packager}\n".
[47]	944	( $pkgdata{$pkg}{requires} ne '' ? "Depends: $pkgdata{$pkg}{requires}\n" : '' ).
[39]	945	( defined($pkgdata{$pkg}{provides}) ? "Provides: $pkgdata{$pkg}{provides}\n" : '' ).
[51]	946	( defined($pkgdata{$pkg}{conflicts}) ? "Conflicts: $pkgdata{$pkg}{conflicts}\n" : '' ).
[27]	947	"Description: $pkgdata{$pkg}{summary}\n";
	948	$control .= "$pkgdata{$pkg}{desc}\n";
[8]	949
[27]	950	open CONTROL, ">$buildroot/$pkg/DEBIAN/control";
	951	print CONTROL $control;
	952	close CONTROL;
[8]	953
[37]	954	# Iff there are conffiles (as specified in the %files list(s), add'em
	955	# in so dpkg-deb can tag them.
	956	if ($pkgdata{$pkg}{conffiles}) {
	957	open CONFLIST, ">$buildroot/$pkg/DEBIAN/conffiles";
	958	foreach my $conffile (@{$pkgdata{$pkg}{conflist}}) {
	959	print CONFLIST "$conffile\n";
	960	}
	961	close CONFLIST;
	962	}
	963
[75]	964	# found the point of scripts on subpackages.
	965	if ($pkgdata{$pkg}{'pre'}) {
	966	$pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'pre'},'gp');
	967	open PREINST, ">$buildroot/$pkg/DEBIAN/preinst";
	968	print PREINST "#!/bin/sh\nset -e\n\n";
	969	print PREINST $pkgdata{$pkg}{'pre'};
	970	close PREINST;
	971	`chmod 0755 $buildroot/$pkg/DEBIAN/preinst`;
[27]	972	}
[75]	973	if ($pkgdata{$pkg}{'post'}) {
	974	$pkgdata{$pkg}{'post'} = expandmacros($pkgdata{$pkg}{'post'},'gp');
	975	open PREINST, ">$buildroot/$pkg/DEBIAN/postinst";
	976	print PREINST "#!/bin/sh\nset -e\n\n";
	977	print PREINST $pkgdata{$pkg}{'post'};
	978	close PREINST;
	979	`chmod 0755 $buildroot/$pkg/DEBIAN/postinst`;
	980	}
	981	if ($pkgdata{$pkg}{'preun'}) {
	982	$pkgdata{$pkg}{'pre'} = expandmacros($pkgdata{$pkg}{'preun'},'gp');
	983	open PREINST, ">$buildroot/$pkg/DEBIAN/prerm";
	984	print PREINST "#!/bin/sh\nset -e\n\n";
	985	print PREINST $pkgdata{$pkg}{'preun'};
	986	close PREINST;
	987	`chmod 0755 $buildroot/$pkg/DEBIAN/prerm`;
	988	}
	989	if ($pkgdata{$pkg}{'postun'}) {
	990	$pkgdata{$pkg}{'postun'} = expandmacros($pkgdata{$pkg}{'postun'},'gp');
	991	open PREINST, ">$buildroot/$pkg/DEBIAN/postrm";
	992	print PREINST "#!/bin/sh\nset -e\n\n";
	993	print PREINST $pkgdata{$pkg}{'postun'};
	994	close PREINST;
	995	`chmod 0755 $buildroot/$pkg/DEBIAN/postrm`;
	996	}
[16]	997
[27]	998	# execute
	999	print "Calling package creation script $debscriptfile for $pkgdata{$pkg}{name}...\n";
	1000	system("/bin/sh -e $debscriptfile") == 0
[14]	1001	or die "Can't exec: $!\n";
[8]	1002
[77]	1003	$finalmessages .= "Wrote binary package ".
[87]	1004	"$pkgdata{$pkg}{name}_$pkgdata{$pkg}{version}-$pkgdata{main}{release}_$pkgdata{$pkg}{arch}.deb".
	1005	" in $topdir/DEBS/$pkgdata{$pkg}{arch}\n";
[27]	1006	# and clean up
	1007	unlink $debscriptfile;
	1008
	1009	} # subpackage loop
	1010
[8]	1011	} # end binpackage()
	1012
	1013
[35]	1014	## srcpackage()
	1015	# Builds a .src.deb source package. Note that Debian's idea of
	1016	# a "source package" is seriously flawed IMO, because you can't
	1017	# easily copy it as-is.
[36]	1018	# Not quite identical to RPM, but Good Enough (TM).
[35]	1019	sub srcpackage {
[54]	1020	# In case we were called with -bs.
	1021	$pkgdata{main}{name} =~ tr/_/-/;
[36]	1022	my $pkgsrcname = "$pkgdata{main}{name}-$pkgdata{main}{version}-$pkgdata{main}{release}.sdeb";
	1023
	1024	my $paxcmd;
	1025
	1026	# We'll definitely need this later, and may need it sooner.
	1027	(my $barespec = $specfile) =~ s\|.+/([^/]+)$\|$1\|;
	1028
	1029	# Copy the specfile to the build tree, but only if it's not there already.
	1030	##buglet: need to deal with silly case where silly user has put the spec
	1031	# file in a subdir of %{_topdir}/SPECS. Ewww. Silly user!
	1032	if (abs_path($specfile) !~ /^$topdir\/SPECS/) {
	1033	$paxcmd .= "cp $specfile %{_topdir}/SPECS/; \n"
	1034	}
	1035
[35]	1036	# use pax -w [file] [file] ... >outfile.sdeb
[36]	1037	$paxcmd = "cd $topdir; pax -w ";
[10]	1038
[35]	1039	# tweak source entry into usable form. Need it locally somewhere along the line.
	1040	(my $pkgsrc = $pkgdata{main}{source}) =~ s\|.+/([^/]+)$\|$1\|;
[36]	1041	$paxcmd .= "SOURCES/$pkgsrc ";
[10]	1042
[35]	1043	# create file list: Source[nn], Patch[nn]
	1044	foreach my $specbit (keys %{$pkgdata{main}} ) {
	1045	next if $specbit eq 'source';
[53]	1046	$paxcmd .= "SOURCES/$pkgdata{main}{$specbit} " if $specbit =~ /^patch/;
[36]	1047	##buglet: need to deal with case where patches are listed as URLs?
	1048	# or other extended pathnames? Silly !@$%^&!%%!%!! user!
[35]	1049	}
	1050
[53]	1051	foreach my $source (keys %{$pkgdata{sources}}) {
	1052	$paxcmd .= "SOURCES/$pkgdata{sources}{$source} ";
	1053	}
	1054
[36]	1055	# add the spec file, source package destination, and cd back where we came from.
	1056	$paxcmd .= "SPECS/$barespec > $topdir/SDEBS/$pkgsrcname; cd -";
[35]	1057
[36]	1058	# In case of %-macros...
[35]	1059	$paxcmd = expandmacros($paxcmd,'gp');
	1060
[36]	1061	system "$paxcmd";
[77]	1062	$finalmessages .= "Wrote source package $pkgsrcname in $topdir/SDEBS.\n";
[35]	1063	}
	1064
	1065
[38]	1066	## checkbuildreq()
	1067	# Checks the build requirements (if any)
	1068	# Spits out a rude warning and returns a true-false error if any
	1069	# requirements are not met.
	1070	sub checkbuildreq {
[40]	1071	return 1 if $buildreq eq ''; # No use doing extra work.
[38]	1072
[52]	1073	if ( ! -e "/usr/bin/dpkg-query" ) {
	1074	print "WARNING dpkg-query not found. Can't check build-deps.\n".
	1075	" Required for sucessful build:\n".$buildreq."\n".
	1076	" Continuing anyway.\n";
	1077	return 1;
	1078	}
	1079
[38]	1080	my $reqflag = 1; # unset iff a buildreq is missing
	1081
	1082	$buildreq =~ s/^, //; # Strip the leading comma and space
	1083	my @reqlist = split /,\s+/, $buildreq;
	1084
	1085	foreach my $req (@reqlist) {
	1086	my ($pkg,$rel,$ver);
	1087
	1088	# We have two classes of requirements - versioned and unversioned.
	1089	if ($req =~ /[><=]/) {
	1090	# Pick up the details of versioned buildreqs
	1091	($pkg,$rel,$ver) = ($req =~ /([a-z0-9._-]+)\s+([><=]+)\s+([a-z0-9._-]+)/);
	1092	} else {
	1093	# And the unversioned ones.
	1094	$pkg = $req;
	1095	$rel = '>=';
	1096	$ver = 0;
	1097	}
	1098
	1099	my @pkglist = qx { dpkg-query --showformat '\${status}\t\${version}\n' -W $pkg };
	1100	# need to check if no lines returned - means a bad buildreq
	1101	my ($reqstat,undef,undef,$reqver) = split /\s+/, $pkglist[0];
	1102	if ($reqstat !~ /install/) {
	1103	print " * Missing build-dependency $pkg!\n";
	1104	$reqflag = 0;
	1105	} else {
	1106	# gotta be a better way to do this... :/
	1107	if ($rel eq '>=' && !($reqver ge $ver)) {
	1108	print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
	1109	$reqflag = 0;
	1110	}
	1111	if ($rel eq '>' && !($reqver gt $ver)) {
	1112	print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
	1113	$reqflag = 0;
	1114	}
	1115	if ($rel eq '<=' && !($reqver le $ver)) {
	1116	print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
	1117	$reqflag = 0;
	1118	}
	1119	if ($rel eq '<' && !($reqver lt $ver)) {
	1120	print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
	1121	$reqflag = 0;
	1122	}
	1123	if ($rel eq '=' && !($reqver eq $ver)) {
	1124	print " * Buildreq $pkg is installed, but wrong version ($reqver): Need $ver\n";
	1125	$reqflag = 0;
	1126	}
	1127	} # end not installed/installed check
	1128	} # end req loop
	1129
	1130	return $reqflag;
	1131	} # end checkbuildreq()
	1132
	1133
	1134	## getreqs()
	1135	# Find out which libraries/packages are required for any
	1136	# executables and libs in a given file tree.
	1137	# (Debian doesn't have soname-level deps; just package-level)
[41]	1138	# Returns an empty string if the tree contains no binaries.
	1139	# Doesn't work well on shell scripts. but those should be
	1140	# fine anyway. (Yeah, right...)
[38]	1141	sub getreqs() {
	1142	my $pkgtree = $_[0];
	1143
[39]	1144	print "Checking library requirements...\n";
[43]	1145	my @binlist = qx { find $pkgtree -type f -perm 755 };
[38]	1146
[41]	1147	if (scalar(@binlist) == 0) {
	1148	return '';
	1149	}
	1150
	1151	my @reqlist;
	1152	foreach (@binlist) {
	1153	push @reqlist, qx { ldd $_ };
	1154	}
	1155
	1156	# Get the list of libs provided by this package. Still doesn't
	1157	# handle the case where the lib gets stuffed into a subpackage. :/
	1158	my @intprovlist = qx { find $pkgtree -type f -name ".so" };
	1159	my $provlist = '';
	1160	foreach (@intprovlist) {
	1161	s/$pkgtree//;
	1162	$provlist .= "$_";
	1163	}
	1164
[38]	1165	my %reqs;
[43]	1166	my $reqlibs = '';
[38]	1167
	1168	foreach (@reqlist) {
	1169	next if /^$pkgtree/;
[42]	1170	next if /not a dynamic executable/;
[41]	1171	next if m\|/lib/ld-linux.so\|; # Hack! Hack! PTHBTT! (libc suxx0rz)
[38]	1172
[41]	1173	my ($req) = (/^\s+([a-z0-9._-]+)/); # dig out the actual library (so)name
	1174
	1175	# Ignore libs provided by this package. Note that we don't match
	1176	# on word-boundary at the end of the lib we're looking for, as the
	1177	# looked-for lib may not have the full soname version. (ie, it may
	1178	# "just" point to one of the symlinks that get created somewhere.)
	1179	next if $provlist =~ /\b$req/;
	1180
[38]	1181	$reqlibs .= " $req";
	1182	}
	1183
[43]	1184	if ($reqlibs ne '') {
	1185	foreach (qx { dpkg -S $reqlibs }) {
	1186	my ($libpkg,undef) = split /:\s+/;
	1187	$reqs{$libpkg} = 1;
	1188	}
[38]	1189	}
	1190
[43]	1191	my $deplist = '';
[38]	1192	foreach (keys %reqs) {
	1193	$deplist .= ", $_";
	1194	}
	1195
	1196	# For now, we're done. We're not going to meddle with versions yet.
	1197	# Among other things, it's messier than handling "simple" yes/no "do
	1198	# we have this lib?" deps. >:(
	1199
	1200	return $deplist;
	1201	} # end getreqs()
	1202
	1203
[50]	1204	## install_sdeb()
	1205	# Extracts .sdeb contents to %_topdir as appropriate
	1206	sub install_sdeb {
[92]	1207	$srcpkg = abs_path($srcpkg);
	1208
[50]	1209	my $paxcmd = "cd $topdir; pax -r <$srcpkg; cd -";
	1210
	1211	# In case of %-macros...
	1212	$paxcmd = expandmacros($paxcmd,'gp');
	1213
	1214	system "$paxcmd";
	1215	print "Extracted source package $srcpkg to $topdir.\n";
	1216	} # end install_sdeb()
	1217
	1218
[10]	1219	## expandmacros()
	1220	# Expands all %{blah} macros in the passed string
[14]	1221	# Split up a bit with some sections so we don't spend time trying to
	1222	# expand macros that are only used in a few specific places.
[10]	1223	sub expandmacros {
	1224	my $macrostring = shift;
[14]	1225	my $section = shift;
[10]	1226
[25]	1227	# To allow the FHS-ish %configure and %makeinstall to work The Right Way.
[12]	1228	# (Without clobbering the global $buildroot.)
	1229	my $prefix = '';
	1230
[11]	1231	if ($section =~ /c/) {
[12]	1232	# %configure macro
[17]	1233	# Don't know what it's for, don't have a useful default replacement
	1234	# --program-prefix=%{_program_prefix} \
	1235	$macrostring =~ s'%configure'./configure --host=$DEB_HOST_GNU_TYPE \
	1236	--build=$DEB_BUILD_GNU_TYPE \
	1237	--prefix=%{_prefix} \
	1238	--exec-prefix=%{_exec_prefix} \
	1239	--bindir=%{_bindir} \
	1240	--sbindir=%{_sbindir} \
	1241	--sysconfdir=%{_sysconfdir} \
	1242	--datadir=%{_datadir} \
	1243	--includedir=%{_includedir} \
	1244	--libdir=%{_libdir} \
	1245	--libexecdir=%{_libexecdir} \
	1246	--localstatedir=%{_localstatedir} \
	1247	--sharedstatedir=%{_sharedstatedir} \
	1248	--mandir=%{_mandir} \
	1249	--infodir=%{_infodir} ';
[12]	1250	} # done %configure
	1251
	1252	if ($section =~ /m/) {
	1253	$macrostring =~ s'%{__make}'make ';
[25]	1254	} # done make
[12]	1255
	1256	if ($section =~ /i/) {
	1257	# This is where we need to mangle $prefix.
[24]	1258	$macrostring =~ s'%makeinstall'make %{fhs} install';
[12]	1259	$prefix = $buildroot;
	1260	} # done %install and/or %makeinstall
	1261
	1262	# Build data
	1263	# Note that these are processed in reverse order to get the substitution order right
	1264	if ($section =~ /b/) {
[24]	1265	# $macrostring =~ s'%{fhs}'host=$DEB_HOST_GNU_TYPE \
	1266	# build=$DEB_BUILD_GNU_TYPE \
	1267	$macrostring =~ s'%{fhs}'prefix=%{_prefix} \
[17]	1268	exec-prefix=%{_exec_prefix} \
	1269	bindir=%{_bindir} \
	1270	sbindir=%{_sbindir} \
	1271	sysconfdir=%{_sysconfdir} \
	1272	datadir=%{_datadir} \
	1273	includedir=%{_includedir} \
	1274	libdir=%{_libdir} \
	1275	libexecdir=%{_libexecdir} \
	1276	localstatedir=%{_localstatedir} \
	1277	sharedstatedir=%{_sharedstatedir} \
	1278	mandir=%{_mandir} \
	1279	infodir=%{_infodir} \
	1280	';
[10]	1281
	1282	# Note that the above regex terminates with the extra space
[12]	1283	# "Just In Case" of user additions, which will then get neatly
	1284	# tagged on the end where they take precedence (supposedly)
	1285	# over the "default" ones.
[10]	1286
[14]	1287	# Now we cascade the macros introduced above. >_<
	1288	# Wot ot to go theah:
	1289	$macrostring =~ s\|%{_mandir}\|%{_datadir}/man\|g; #/usr/share/man
	1290	$macrostring =~ s\|%{_infodir}\|%{_datadir}/info\|g; #/usr/share/info
[25]	1291	$macrostring =~ s\|%{_oldincludedir}\|/usr/include\|g; #/usr/include
[84]	1292	$macrostring =~ s\|%{_includedir}\|%{_prefix}/include\|g; #/usr/include
[25]	1293	$macrostring =~ s\|%{_libdir}\|%{_exec_prefix}/%{_lib}\|g; #/usr/lib
[14]	1294	$macrostring =~ s\|%{_lib}\|lib\|g; #?
[25]	1295	$macrostring =~ s\|%{_localstatedir}\|/var\|g; #/var
	1296	$macrostring =~ s\|%{_sharedstatedir}\|%{_prefix}/com\|g; #/usr/com WTF?
	1297	$macrostring =~ s\|%{_sysconfdir}\|/etc\|g; #/etc
	1298	$macrostring =~ s\|%{_datadir}\|%{_prefix}/share\|g; #/usr/share
	1299	$macrostring =~ s\|%{_libexecdir}\|%{_exec_prefix}/libexec\|g; #/usr/libexec
	1300	$macrostring =~ s\|%{_sbindir}\|%{_exec_prefix}/sbin\|g; #/usr/sbin
	1301	$macrostring =~ s\|%{_bindir}\|%{_exec_prefix}/bin\|g; #/usr/bin
	1302	$macrostring =~ s\|%{_exec_prefix}\|%{_prefix}\|g; #/usr
[14]	1303	$macrostring =~ s\|%{_prefix}\|/usr\|g; #/usr
[10]	1304	} # done with config section
	1305
[12]	1306	# Package data
	1307	if ($section =~ /p/) {
[15]	1308	$macrostring =~ s/\%\{buildroot\}/$buildroot/gi;
	1309	foreach my $source (keys %{$pkgdata{sources}}) {
	1310	$macrostring =~ s/\%\{source$source\}/$topdir\/SOURCES\/$pkgdata{sources}{$source}/gi;
	1311	}
	1312	$macrostring =~ s/\%\{name\}/$pkgdata{main}{name}/gi;
	1313	$macrostring =~ s/\%\{version\}/$pkgdata{main}{version}/gi;
	1314	$macrostring =~ s/\%\{release\}/$pkgdata{main}{release}/gi;
[12]	1315	}
	1316
	1317	# Globals, and not-so-globals
	1318	if ($section =~ /g/) {
[60]	1319
	1320	# special %define's. Handle the general case where we eval anything.
[93]	1321	# Even more general: %(...) is a spec-parse-time shell code wrapper.
[60]	1322	# Prime example:
	1323	#%define perl_vendorlib %(eval "`perl -V:installvendorlib`"; echo $installvendorlib)
[93]	1324	if ($macrostring =~ /^\%\(.+\)$/) {
[60]	1325	$macrostring =~ s/^\%\(//;
	1326	$macrostring =~ s/\)$//;
	1327	# Oy vey this gets silly for the perl bits. Executing a shell to
	1328	# call Perl to get the vendorlib/sitelib/whatever "core" globals.
	1329	# This can do more, but... eww.
	1330	# Next line is non-optimal - what if $macrostring contains ' characters?
	1331	$macrostring = qx { /bin/sh -c '$macrostring' };
	1332	}
	1333
[29]	1334	$macrostring =~ s\|%{_builddir}\|%{_topdir}/BUILD\|g;
	1335	$macrostring =~ s\|%{_topdir}\|$topdir\|g;
[13]	1336	$macrostring =~ s\|%{_tmppath}\|$tmpdir\|g;
[84]	1337	$macrostring =~ s'%{_docdir}'%{_datadir}/doc'g;
[23]	1338
[31]	1339	# Standard FHS locations. More or less.
[30]	1340	$macrostring =~ s'%{_bindir}'/usr/bin'g;
[31]	1341	$macrostring =~ s'%{_sbindir}'/usr/sbin'g;
[84]	1342	$macrostring =~ s'%{_mandir}'%{_datadir}/man'g;
[30]	1343	$macrostring =~ s'%{_includedir}'/usr/include'g;
[31]	1344	$macrostring =~ s'%{_libdir}'/usr/lib'g;
	1345	$macrostring =~ s'%{_sysconfdir}'/etc'g;
	1346	$macrostring =~ s'%{_localstatedir}'/var'g;
[30]	1347
[84]	1348	# FHS-ish locations that aren't quite actually FHS-specified.
	1349	$macrostring =~ s'%{_datadir}'/usr/share'g;
	1350
[23]	1351	# %define's
	1352	foreach my $key (keys %specglobals) {
	1353	$macrostring =~ s\|%{$key}\|$specglobals{$key}\|g;
	1354	}
	1355
[95]	1356	# support for some %if constructs. Note that this breaks somewhat if
	1357	# there's no value specified... but so does rpm.
	1358	while ($macrostring =~ /\%\{\?(\!)?([a-z0-9_.-]+)(?:\:([a-z0-9_.-]+))?\}/) { #Whew....
	1359	my $neg = $1;
	1360	my $macro = $2;
	1361	my $value = $3;
	1362	if ($specglobals{$macro}) {
	1363	$value = '' if $neg;
	1364	} else {
	1365	$value = '' if !$neg;
	1366	}
	1367	$macrostring =~ s/\%\{\?\!?[a-z0-9_.-]+(?:\:[a-z0-9_.-]+)?\}/$value/;
	1368	}
	1369
[23]	1370	# system programs. RPM uses a global config file for these; we'll just
	1371	# ASS-U-ME and make life a little simpler.
	1372	if ($macrostring =~ /\%\{\_\_([a-z0-9_-]+)\}/) {
	1373	$macrostring =~ s\|%{__([a-z0-9_-]+)}\|$1\|g;
	1374	}
[87]	1375
	1376	# Misc expansions
	1377	$macrostring =~ s\|%{_arch}\|$hostarch\|g;
	1378	$macrostring =~ s\|%{optflags}\|$optflags{$hostarch}\|g;
	1379
[10]	1380	} # done with globals section
	1381
	1382	return $macrostring;
	1383	} # end expandmacros()
[22]	1384
	1385
	1386
[38]	1387	__END__
	1388
	1389
	1390
[22]	1391	=head1 NAME
	1392
	1393	debbuild - Build Debian-compatible packages from RPM spec files
	1394
	1395	=head1 SYNOPSIS
	1396
	1397	debbuild {-ba\|-bb\|-bp\|-bc\|-bi\|-bl\|-bs} [build-options] file.spec
	1398
	1399	debbuild {-ta\|-tb\|-tp\|-tc\|-ti\|-tl\|-ts} [build-options] file.tar.{gz\|bz2}
	1400
[55]	1401	debbuild --rebuild file.{src.rpm\|sdeb}
[22]	1402
[89]	1403	debbuild --showpkgs
	1404
[22]	1405	=head1 DESCRIPTION
	1406
[55]	1407	This script attempts to build Debian-friendly semi-native packages from RPM spec files,
	1408	RPM-friendly tarballs, and RPM source packages (.src.rpm files). It accepts I<most> of the
	1409	options rpmbuild does, and should be able to interpret most spec files usefully. Perl
	1410	modules should be handled via CPAN+dh-make-perl instead; Debian's conventions for such
	1411	things do not lend themselves to automated conversion.
[22]	1412
[55]	1413	As far as possible, the command-line options are identical to those from rpmbuild, although
[57]	1414	several rpmbuild options are not supported:
[22]	1415
[57]	1416	--recompile
	1417	--showrc
	1418	--buildroot
	1419	--clean
	1420	--nobuild
	1421	--rmsource
	1422	--rmspec
	1423	--sign
	1424	--target
	1425
	1426	Some of these could probably be trivially added. Feel free to send me a patch. ;)
	1427
	1428	Complex spec files will most likely not work well, if at all. Rewrite them from scratch -
	1429	you'll have to make heavy modifications anyway.
	1430
	1431	If you see something you don't like, mail me. Send a patch if you feel inspired. I don't
	1432	promise I'll do anything other than say "Yup, that's broken" or "Got your message".
	1433
[55]	1434	=head1 ASSUMPTIONS
	1435
	1436	As with rpmbuild, debbuild makes some assumptions about your system.
	1437
	1438	=over 4
	1439
	1440	=item *
	1441
	1442	Either you have rights to do as you please under /usr/src/debian, or you have created a file
	1443	~/.debmacros containing a suitable %_topdir definition.
	1444
[57]	1445	Both rpmbuild and debbuild require the directories %_topdir/{BUILD,SOURCES,SPECS}. However,
	1446	where rpmbuild requires the %_topdir/{RPMS,SRPMS} directories, debbuild
	1447	requires %_topdir/{DEBS,SDEBS} instead. Create them in advance;
[55]	1448	some subdirectories are created automatically as needed, but most are not.
	1449
	1450	=item *
	1451
	1452	/var/tmp must allow script execution - rpmbuild and debbuild both rely on creating and
	1453	executing shell scripts for much of their functionality. By default, debbuild also creates
	1454	install trees under /var/tmp - however this is (almost) entirely under the control of the
	1455	package's .spec file.
	1456
	1457	=item *
	1458
	1459	If you wish to --rebuild a .src.rpm, your %_topdir for both debbuild and rpmbuild must either
	1460	match, or be suitably symlinked one direction or another so that both programs are effectively
	1461	working in the same tree. (Or you could just manually wrestle files around your system.)
	1462
	1463	You could symlink ~/.rpmmacros to ~/.debmacros (or vice versa) and save yourself some hassle
	1464	if you need to rebuild .src.rpm packages on a regular basis. Currently debbuild only uses the
	1465	%_topdir macro definition, although there are many more things that rpmbuild can use from
	1466	~/.rpmmacros.
	1467
	1468	=back
	1469
[89]	1470	=head1 ERRATA
	1471
	1472	debbuild deliberately does a few things differently from rpm.
	1473
	1474	=head2 BuildArch or BuildArchitecture
	1475
	1476	rpm takes the last BuildArch entry it finds in the .spec file, whatever it is, and runs with
	1477	that for all packages. Debian's repository system is fairly heavily designed around the
	1478	assumption that a single source package may generate small binary (executable) packages
	1479	for each arch, and large binary arch-all packages containing shared data.
	1480
	1481	debbuild allows this by using the architecture specified by (in order of preference):
	1482
	1483	=over 4
	1484
	1485	=item * Host architecture
	1486
	1487	=item * BuildArch specified in .spec file preamble
	1488
	1489	=item * "Last specified" BuildArch for packages with several subpackages
	1490
	1491	=item * BuildArch specified in the %package section for that subpackage
	1492
	1493	=back
	1494
	1495	=head2 Finding out what packages should be built (--showpkgs)
	1496
	1497	rpmbuild does not include any convenient method I know of to list the packages a spec file
	1498	will produce. Since I needed this ability for another tool, I added it.
	1499
	1500	It requires the .spec file for the package, and produces a list of full package filenames
	1501	(without path data) that would be generated by one of --rebuild, -ta, -tb, -ba, or -bb.
	1502	This includes the .sdeb source package.
	1503
[57]	1504	=head1 AUTHOR
[55]	1505
[57]	1506	debbuild was written by Kris Deugau <kdeugau@deepnet.cx>. A version that approximates
	1507	current is available at http://www.deepnet.cx/debbuild/.
[55]	1508
	1509	=head1 BUGS
	1510
[57]	1511	Funky Things Happen if you forget a command-line option or two. I've been too lazy to bother
	1512	fixing this.
[55]	1513
[57]	1514	Many macro expansions are unsupported or incompletely supported.
	1515
	1516	The generated scriptlets don't quite match those from rpmbuild exactly. There are extra
	1517	environment variables and preprocessing that I haven't needed (yet).
	1518
	1519	Dcumentation, such as it is, will likely remain perpetually out of date.
	1520
	1521	%_topdir and the five "working" directories under %_topdir could arguably be created by
	1522	debbuild. However, rpmbuild doesn't create these directories either.
	1523
	1524	=head1 SEE ALSO
	1525
	1526	rpm(8), rpmbuild(8), and pretty much any document describing how to write a .spec file.
	1527
[22]	1528	=cut

Note: See TracBrowser for help on using the repository browser.

Download in other formats: