Context Navigation

source: trunk/debbuild@ 121

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

/trunk

Massive cleanup of %files handling. Still not "complete", but much better.
%attr + %config + %doc (in all possible combinations) should be handled
about as close as I can get to rpmbuild's behaviour.

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

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

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

Download in other formats: