Non usate "test" come nome di un file eseguibile di prova.
test è un comando interno di shell.
Riferimenti:
/usr/share/doc/pacchetti
Unix / Programming
Information
Molti documenti info più lunghi possono essere ottenuti rilegati da GNU.
Le quattro sezioni a seguire contengono dei semplici script, in linguaggi
differenti, per creare un file di testo contenente le informazioni di account,
da aggiungere a /etc/passwd, utilizzando un processore batch come
il programma newusers. Ogni script richiede come input un file
con le righe sotto forma di nome cognome password. (Le directory
home reali di ciascun utente non vengono create con questi script.)
Leggere gli script della shell è il miglior modo per
comprendere il funzionamento di un sistema tipo Unix. Qui fornisco alcuni
indirizzi per la programmazione nella shell. Vedere Errori di
Shell per imparare dagli errori.
Riferimenti per Bash:
bash(1)
BASH Programming -
Introduction HOWTO per iniziare.
(Installate il pacchetto bash-doc per vedere dei file di esempio.)
Esempio di programma breve (crea delle voci di account per
newusers a partire da un input standard):
#!/bin/bash
# (C) Osmu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
pid=1000;
while read n1 n2 n3 ; do
if [ ${n1:0:1} != "#" ]; then
let pid=$pid+1
echo ${n1}_${n2}:password:${pid}:${pid}:,,,/home/${n1}_${n2}:/bin/bash
fi
done
Parecchi pacchetti forniscono una shell POSIX shell in Debian:
dash (Sarge)
ash (Woody)
bash
pdksh
Se scrivete uno script che sia portatile, è meglio scriverlo come script POSIX.
Usate /bin/sh collegato a ash o (dash)
per testarne la complianza con POSIX. Evitate di scrivere gli script con
espressioni tipiche di bash o zsh. Evitate, per esempio:
La descrizione per la shell in questo documenti si applica solo per le shell
POSIX e perciò non si applica alle shell di tipo csh, inclusa
tcsh.
Ecco parecchi parametri speciali da ricordare:
$0 = nome della shell o dello script
$1 = primo(1) argomento della shell
...
$9 = nono(9) argomento della shell
$# = numero dei parametri posizionali
"$*" = "$1 $2 $3 $4 ... $n"
"$@" = "$1" "$2" "$3" "$4" ... "$n"
$? = stato di uscita del comando più recente
$$ = PID di questo script
$! = PID del processo più recente lanciato in background
Espansioni dei parametri basilari da ricordare:
Forma Se var è impostata(*) Se var non è impostata(*)
${var:-stringa} $var stringa
${var:+stringa} stringa null
${var:=stringa} $var stringa
(e lancia var=stringa)
${var:?stringa} $var (echo stringa ed esce)
I due punti, qui, `:' in tutti questi operatori sono opzionali.
Sostituzioni dei parametri basilari da ricordare:
Forma Risultato
${var%suffisso} Rimuove il più piccolo pattern suffisso
${var%%suffisso} Rimuove il più largo pattern suffisso
${var#prefisso} Rimuove il più piccolo pattern prefisso
${var##prefisso} Rimuove il più largo pattern prefisso
Redirezione basilare da ricordare (dove [n] è un numero opzionale per specificare il descrittore del file):
[n]> file Redirige l'output standard (o n) a file.
[n]>> file Aggiunge l'output standard (o n) a file.
[n]< file Redirige l'input standard (o n) da file.
[n1]>&n2 Redirige l'output standard (o n1) a n2.
> file >&2 Redirige l'output standard e di errore a file.
| comando Con una pipe invia l'output standard (o n) a comando.
>&2 | comando Coun una pipe invia l'output standard e di errore a comando.
2>&1 | command Pipe stderr and stdout to command.
Dove,
La shell vi permette di aprire i file mediante exec con un
descrittore di file arbitrario.
$ echo Hello >foo
$ exec 3<foo 4>bar # apre i file
$ cat <&3 >&4 # redirige stdin a 3, stdout a 4
$ exec 3<&- 4>&- # chiude i file
$ cat bar
Hello
Qui n<&- e n>&- significano chiudere il descrittore del file n.
Ciascun comando ritorna uno stato di uscita che può essere utilizzato per le espressioni condizionali:
Notate che l'utilizzo del valore 0 per "vero" differisce dalle
convenzioni usuali in altre aree di programmazione. In aggiunta, `[' è
l'equivalente del comando test, che valuta i suoi argomenti fino a
`]' come espressione condizionale.
Idiomi condizionali basilari da ricordare sono:
comando && se_successo_lancia_anche_questo_comando
comando || se_non_ha_successo_lancia_anche_questo_comando
if [ espressione_condizionale ]; then
se_ha_successo_lancia_anche_questo_comando
else
se_non_ha_successo_lancia_anche_questo_comando
fi
Qui, || true era necessario per assicurarsi che lo script non uscisse a questa riga accidentalmente, quando la shell era invocata con l'opzione -e.
Gli operatori per la comparazione dei file nelle espressioni condizionali sono:
-e file Vero se file esiste.
-d file Vero se file esiste ed è una directory.
-f file Vero se file esiste ed è un file regolare.
-w file Vero se file esiste ed è scrivibile.
-x file Vero se file esiste ed è eseguibile.
file1 -nt file2 Vero se file1 è più recente di file2. (modificato)
file1 -ot file2 Vero se file1 è più vecchio di file2. (modificato)
file1 -ef file2 Vero se se sono gli stessi numeri di inode e device.
Gli operatori di comparazione delle stringhe nelle espressioni condizionali sono:
-z str Vero se la lunghezza di str è zero.
-n str Vero se la lunghezza di str è non-zero.
str1 == str2 Vero se str sono uguali.
str1 = str2 Vero se str sono uguali.
("=" dovrebbe essere usato al posto di "==", per una stretta
complianza POSIX )
str1 != str2 Vero se str non sono uguali.
str1 < str2 Vero se str1 viene prima di str2 (dipende da locale).
str1 > str2 Vero se str1 viene dopo str2 (dipende da locale).
Gli operatori aritmetici di comparazione degli interi nelle espressioni condizionali sono -eq, -ne, -lt, -le, -gt, o -ge.
La shell processa uno script come segue:
Le virgolette semplici all'interno delle doppie non hanno effetto.
Eseguire set -x nella shell, o invocarla con l'opzione -x fa sì che stampi tutti i comandi eseguiti. Molto utile per il debugging.
Riferimenti per Awk:
mawk(1) e gawk(1)
Esempio di programma breve (crea delle voci di account per
newusers):
#!/usr/bin/awk -f
# Script per creare un file utilizzabile con il comando 'newusers',
# a partire da un file che contiene user IDs e passwords sotto forma di:
# Nome Cognome password
# Copyright (c) KMSelf Sat Aug 25 20:47:38 PDT 2001
# Distributed under GNU GPL v 2, or at your option, any later version.
# This program is distributed WITHOUT ANY WARRANTY.
BEGIN {
# Assign starting UID, GID
if ( ARGC > 2 ) {
startuid = ARGV[1]
delete ARGV[1]
}
else {
printf( "Usage: newusers startUID file\n" \
" where:\n" \
" startUID is the starting userid to add, and\n" \
" file is an input file in form:\n" \
" first_name last_name password\n" \
)
exit
}
infile = ARGV[1]
printf( "Starting UID: %s\n\n", startuid )
}
/^#/ { next }
{
++record
first = $1
last = $2
passwd = $3
user= substr( tolower( first ), 1, 1 ) tolower( last )
uid = startuid + record - 1
gid = uid
printf( "%s:%s:%d:%d:%s %s,,/home/%s:/bin/bash\n", \
user, passwd, uid, gid, first, last, user \
)
}
Due sono i pacchetti che forniscono il POSIX awk in Debian:
mawk
gawk
Questo è l' interprete su un sistema simil-Unix.
Riferimenti per Perl:
perl(1)
La directory Perl
Esempio di programma breve (crea delle voci di account per
newusers):
#!/usr/bin/perl
# (C) Osamu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
$pid=1000;
while (<STDIN>) {
if (/^#/) { next;}
chop;
$pid++;
($n1, $n2, $n3) = split / /;
print $n1,"_",$n2,":", $n3, ":",$pid,
":",$pid,",,,/home/",$n1,"_",$n2,":/bin/bash\n"
}
Installate il modulo Perl module_name:
# perl -MCPAN -e 'install module_name'
E' un valido interprete object-oriented.
Riferimenti per Python:
python(1)
Python Programming Language
Esempio di programma breve (crea delle voci di account per
newusers):
#! /usr/bin/env python
import sys, string
# (C) Osamu Aoki Sun Aug 26 16:53:55 UTC 2001 Public Domain
# Ported from awk script by KMSelf Sat Aug 25 20:47:38 PDT 2001
# This program is distributed WITHOUT ANY WARRANTY.
def usages():
print \
"Usage: ", sys.argv[0], " start_UID [filename]\n" \
"\tstartUID is the starting userid to add.\n" \
"\tfilename is input filename. If not specified, standard input.\n\n" \
"Input file format:\n"\
"\tfirst_name lastname password\n"
return 1
def parsefile(startuid):
#
# main filtering
#
uid = startuid
while 1:
line = infile.readline()
if not line:
break
if line[0] == '#':
continue
(first, last, passwd) = string.split(string.lower(line))
# above crash with wrong # of parameters :-)
user = first[0] + last
gid = uid
lineout = "%s:%s:%d:%d:%s %s,,/home/%s:/bin/bash\n" % \
(user, passwd, uid, gid, first, last, user)
sys.stdout.write(lineout)
+uid
if __name__ == '__main__':
if len(sys.argv) == 1:
usages()
else:
uid = int(sys.argv[1])
#print "# UID start from: %d\n" % uid
if len(sys.argv) > 1:
infilename = string.join(sys.argv[2:])
infile = open(infilename, 'r')
#print "# Read file from: %s\n\n" % infilename
else:
infile = sys.stdin
parsefile(uid)
Riferimenti per Make:
make(1)
Semplici variabili automatiche:
Regole di sintassi:
target: [ prerequisites ... ]
[TAB] command1
[TAB] -command2 # ignora gli errori
[TAB] @command3 # sopprime l'eco
Qui [TAB] è un codice TAB. Ogni riga viene interpretata dalla shell dopo la sostituzione della variabile da parte di make. Usate \ alla fine della riga per continuare a capo lo script. Usate $$ per $ per le variabili d'ambiente dello shell script.
Le regole implicite per target e prerequisites può essere scritta, per esempio come:
%: %.c header.h
oppure,
%.o: %.c header.h
Qui, target contiene il carattere % (esattamente uno di loro). Il % può corrispondere con qualsiasi sottostringa non vuota nei file target attuali. Similmente prerequisites usa % come i loro nomi si correlano al nome del target attuale.
Le regole di suffisso sono il vecchio modo di
definire le regole implicite per make. Sono ancora supportate in
GNU make per compatibilità, ma usate quando possibile le regole
equivalenti del modello:
vecchia regola --> nuova regola
.c: --> % : %.c
.c.o: --> %.o: %.c
Variabili automatiche per le summenzionate regole:
foo.o: new1.c new2.c old1.c new3.c
$@ == foo.o (obiettivo)
$< == new1.c (il primo)
$? == new1.c new2.c new3.c (i più recenti)
$^ == new1.c new2.c.c old1.c new3.c (tutti)
$* == `%' motivo corrispondente al motivo obiettivo.
Riferimenti delle variabili:
foo1 := bar # Espansione unica
foo2 = bar # Espansione ricorsiva
foo3 += bar # Appendi
SRCS := $(wildcard *.c)
OBJS := $(foo:c=o)
OBJS := $(foo:%.c=%.o)
OBJS := $(patsubst %.c,%.o,$(foo))
DIRS = $(dir directory/filename.ext) # Estrae la "directory"
$(notdir NAMES...), $(basename NAMES...), $(suffix NAMES...) ...
Per vedere le regole interne automatiche, lanciate make -p -f/dev/null.
Preparazione:
# apt-get install glibc-doc manpages-dev libc6-dev gcc
Riferimenti per C:
gcc(1)
qualsiasi_nome_funzione_libreria_C(3)
gcc)
Un semplice esempio di compilazione di example.c, con una libreria
libm in un eseguibile run_example:
$ cat > example.c << EOF
#include <stdio.h>
#include <math.h>
#include <string.h>
int main(int argc, char **argv, char **envp){
double x;
char y[11];
x=sqrt(argc+7.5);
strncpy(y, argv[0], 10); /* prevent buffer overflow */
y[10] = '\0'; /* fill to make sure string ends with '\0' */
printf("%5i, %5.3f, %10s, %10s\n", argc, x, y, argv[1]);
return 0;
}
EOF
$ gcc -Wall -g -o run_example example.c -lm
$ ./run_example
1, 2.915, ./run_exam, (null)
$ ./run_example 1234567890qwerty
2, 3.082, ./run_exam, 1234567890qwerty
Qui, -lm è necessario per il collegamento della
libreria libm per sqrt(). La
libreria vera è in /lib con il nome libm.so.6,
collegamento simbolico a libm-2.1.3.so.
Guardate l'ultimo parametro nel testo risultante. Ci sono più di 10 caratteri, anche se viene specificato %10s.
L'uso di puntatori di funzioni che richiedano operazioni in memoria senza
controlli sui loro "confini", tipo sprintf e
strcpy, non è considerato sufficiente a prevenire gli effetti di
exploit tipo buffer overflow, che annullano gli effetti di overrun.
Utilizzate, invece, snprintf e strncpy.
gdbPreparazione:
# apt-get install gdb
Riferimenti per gdb:
gdb(1)
http://www.unknownroad.com/rtfm/gdbtut/gdbtoc.html
Per il debugging di un programma compilato con l'opzione -g, usate
gdb. Molti comandi possono essere abbreviati. L'espansione del
comando mediante tab funziona come per la shell.
$ gdb program
(gdb) b 1 # imposta il punto di interruzione alla riga 1
(gdb) run arg1 arg2 arg3 # lancia il programma
(gdb) next # riga successiva
...
(gdb) step # un passo avanti
...
(gdb) p parm # stampa parm
...
(gdb) p parm=12 # imposta il valore di parm a 12
Per il debugging da emacs, fate riferimento a Riassunto dei comandi (Emacs e Vim), Sezione 11.3.4.
Dato che tutti i binari installati devono essere adattati al sistema Debian in
maniera predefinita, gran parte dei simboli di debug sono stati rimossi. Per
rendere gdb utile per il debug dei pacchetti Debian, i pacchetti
pertinenti devono essere ricompilati con la cura seguente:
debian/control per eliminare il pacchetto version.
Vedere Policy
10.1 per maggiori informazioni.
Usate ldd per scoprire da quali librerie dipende un programma:
$ ldd /bin/ls
librt.so.1 => /lib/librt.so.1 (0x4001e000)
libc.so.6 => /lib/libc.so.6 (0x40030000)
libpthread.so.0 => /lib/libpthread.so.0 (0x40153000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
Affinchè ls funzioni in un ambiente chroot le
librerie di cui sopra devono essere disponibili all'interno di esso.
Utili anche i seguenti comandi:
strace: traccia le chiamate di sistema ed i segnali
ltrace: traccia le chiamate alle librerie
Parecchi sono gli strumenti per il riconoscimento dei memory leak in Debian.
njamd
valgrind
dmalloc
electric-fence
memprof
memwatch (non è impacchettato, prendetelo da memwatch.)
mpatrol
leaktracer
libgc6
Parasoft. (non-free, commerciale, a
pagamento)
Vedere anche Debugging
Tools for Dynamic Storage Allocation and Memory Management.
flex è un veloce generatore ed analizzatore lessicale.
Riferimenti per flex:
flex(1)
Al vostro programma dovete fornire una propria main() e
yywrap(), altrimenti program.l apparirà come
nell'esempio qui sotto, tentando la compilazione senza librerie
(yywrap è una macro; %option main diventa
implicitamente %option noyywrap):
%option main
%%
.|\n ECHO ;
%%
In alternativa, potete compilarlo con l'opzione -lfl al termine della riga di comando cc (tipo AT&T-Lex con -ll). In questo caso nessuna %option è richiesta.
Alcuni pacchetti forniscono un LALR parser generator Yacc-compatibile in Debian:
bison: GNU LALR parser generator
byacc: Il Berkeley LALR parser generator
btyacc: Backtracking parser generator basato su byacc
Riferimenti per bison:
bison(1)
Dovete fornire la vostra main() e yyerror().
main() chiama yyparse() che chiama
yylex(), normalmente creata con FleX.
%%
%%
autoconf è uno strumento per produrre degli shell script in grado
di configurare automaticamente il codice sorgente dei programmi usando l'intero
sistema di compilazione GNU, adattandoli a molti tipi di sistema simil-Unix.
autoconf produce lo script di configurazione
configure. configure crea automaticamente un
Makefile personalizzato e Makefile.am.
Debian non tocca i file in /usr/local (vedere Supportare le differenze, Sezione 2.5).
Quindi, se compilate un programma dai sorgenti, installatelo in
/usr/local, così non interferirà con Debian.
$ cd src
$ ./configure --prefix=/usr/local
$ make
$ make install # questo comando mette i file nel sistema
Se avete ancora il sorgente e Se utilizza
autoconf/automake e se ricordate come l'avete
configurato:
$ ./configure tutte-le-opzioni-che-avevate-dato
# make uninstall
In alternativa, se siete assolutamente sicuri che il processo di installazione
pone i file solo sotto /usr/local e che non c'è nulla di
importante lì, potete cancellarne utto il contenuto con:
# find /usr/local -type f -print0 | xargs -0 rm -f
Se non siete sicuri di dove i file siano installati, dovreste prendere in
considerazione l'uso di checkinstall, che fornisce un percorso
pulito per la disinstallazione.
Pagine web interattive dinamiche basilari possono essere create come segue:
program.*) sul server web
riceverà i parametri codificati "VAR1=VAL1 VAR2=VAL2
VAR3=VAL3" come contenuto della variabile di ambiente
"QUERY_STRING" ed esegue sè stesso.
Per motivi di sicurezza è meglio non fare modifiche a mano dei parametri per il
processamento CGI. per loro esistono dei moduli già stabiliti in Perl (vedere
Perl, Sezione 13.4) e Python (vedere Python, Sezione 13.5). PHP arriva con queste funzionalità.
Quando si richiede l'immagazzinamento dei dati del client, si usano i cookie..
Quando ne è richiesto il processamento, su usa frequentemente javascript.
Per altro, vedere The Common
Gateway Interface, The Apache
Software Foundation, e JavaScript.
Cercare su Google "CGI tutorial" digitando l'URL codificata http://www.google.com/search?hl=en&ie=UTF-8&q=CGI+tutorial direttamente nella finestra dell'indirizzo del browser, è un buon modo per vedere lo script CGI in azione sul server.
Tradizionalmente, roff è il principale sistema di scrittura testo in Unix.
Vedere roff(7), groff(7), groff(1),
grotty(1), troff(1), groff_mdoc(7),
groff_man(7), groff_ms(7), groff_me(7),
groff_mm(7), ed "info groff".
Esiste un buon tutorial sulle macro -me. Se avete groff (1.18 o
più recente), trovate /usr/share/doc/groff/meintro.me.gz e fate
quanto segue:
$ zcat /usr/share/doc/groff/meintro.me.gz | \
groff -Tascii -me - | less -R
Quanto segue produrrà un file totalmente in formato testo:
$ zcat /usr/share/doc/groff/meintro.me.gz | \
GROFF_NO_SGR=1 groff -Tascii -me - | col -b -x > meintro.txt
Per la stampa, usate l'output PostScript.
$ groff -Tps meintro.txt | lpr
$ groff -Tps meintro.txt | mpage -2 | lpr
Preparazione:
# apt-get install debiandoc-sgml debiandoc-sgml-doc
Riferimenti per debiandoc-sgml:
/usr/share/doc/debiandoc-sgml-doc
debiandoc-sgml(1)
DocBook:
The Definitive Guide, di Walsh and Muellner (O'Reilly)
(pacchetto docbook-defguide)
SGML permette la gestione dei formati multipli dei documenti. Un sistema SGML semplice è Debiandoc, utilizzato qui. Richiede delle conversioni minori dai file di testo originali per i seguenti
Per marcare una sezione come commento non stampabile, date:
<!-- Il commento va qui ... -->
Per marcare una sezione con un commento modificabile, date:
<![ %FIXME [ Il commento va qui ... ]]>
In SGML, la prima definizione di un'entità vince. Per esempio:
<!entity % qref "INCLUDE">
<![ %qref; [ <!entity param "Data 1"> ]]>
<!entity param "Data 2">
¶m;
Questa termina come "Data 1". Se la prima riga è, invece, "IGNORE", questa terminerà come "Data 2" (La seconda riga è un'affermazione condizionale). Anche le frasi ripetute possono essere definite a priori, separatamente dal contesto.
<!entity dichièquesto "mio">
Ciao amico &dichièquesto;.
Questo è il &dichièquesto; libro.
Che dà ciò come risultato:
Ciao amico mio.
Questo è il mio libro.
Vedere il breve esempio in SGML sample.sgml in esempi.
Quando i documenti SGML diventano voluminosi, talvolta TeX può dare degli errori. Vedere TeX/LaTeX, Sezione 13.9.3.
Preparazione:
# tasksel # scegliete Miscellaneous --> TeX/LaTeX environment
Riferimenti per LaTeX:
The teTeX HOWTO: The
Linux-teTeX Local Guide
tex(1)
latex(1)
Qusto è l'ambiente per la scrittura più potente. Molti processori SGML lo
usano come loro processore back end. Lyx, fornito dal pacchetto
lyx, lyx-xforms, oppure lyx-qt e GNU
TeXmacs fornito da texmacs offrono dei bei ambienti di scrittura
WYSIWYYG per LaTeX, mentre molti usano Emacs e Vim come come edito dei
sorgenti.
Molte sono le risorse disponibili in rete:
teTeX - A Documentation
Guide (il pacchetto tetex-doc)
A Quick Introduction
to LaTeX
A Simple
Guide to Latex/Lyx
Word
Processing Using LaTeX
Local
User Guide to teTeX/LaTeX
Quando i documenti si ingrandiscono, talvolta TeX può causare degli errori.
Dovete aumentare le dimensioni del pool in /etc/texmf/texmf.cnf
(o, più appropriatamente, modificate /etc/texmf/texmf.d/95NonPath
e lanciate update-texmf) per risolvere il problema.
Invece di scrivere codice contenente documentazione, il programmatore letterato scrive documentazione contenente codice. Questo approccio assicura una buona documentazione per un programma.
Per saperne di più sul literate-programming, vedere Literate Programming.
Preparazione:
# apt-get install nowebm
Riferimenti per Noweb:
E' uno strumento per il literate-programming simil-WEB, che è più semplice, e
fornisce allo stesso tempo estensibilità e indipendenza dal tipo di linguaggio.
[72] Quando si invoca
noweb scrive il codice sorgente del programma sui file di output
menzionati nel file noweb, ed un file TeX per la documentazione stampabile.
Il pacchetto Debian ifupdown ne è un raffinato esempio.
$ apt-get source ifupdown
$ cd ifupdown*
$ make ifupdown.pdf ifupdown.ps
Preparazione:
# apt-get install doxygen doxygen-doc doxygen-gui
Riferimenti per Doxygen (creato da doxygen!):
Può generare documentazione HTML, RTF, pagine di manuale Unix, PostScript, PDF
(usando LaTeX) per C++, C, Java, IDL, e programmi PHP e C# in qualche modo.
Doxygen è compatibile con JavaDoc (1.1), Qt-Doc, KDOC e è stato disegnato
specificatamente per essere usato per i progetti che usano il toolkit Troll
Tech Qt. Crea i grafici
delle dipendenze di include, diagrammi collaborativi, e grafici di gerarchie di
classi grafiche persino per i programmi non documentati. L'output è simile
alla documentazione di QT.
Preparazione:
# apt-get install debian-policy developers-reference \
maint-guide dh-make debhelper
# apt-get install packaging-manual # se su Potato
Riferimenti per il packaging:
dh-make(1)
Metodo spiccio per impacchettare un singolo binario, da Joey Hess.
# mkdir -p mypkg/usr/bin mypkg/DEBIAN
# cp binary mypkg/usr/bin
# cat > mypkg/DEBIAN/control
Package: miopacchetto
Version: 1
Architecture: i386
Maintainer: Joey Hess <joeyh@debian.org>
Description: il mio piccolo pacchetto
Non vi aspettate granchè.
^D
# dpkg-deb -b mypkg
Usate dh_make dal pacchetto dh-make per creare un
pacchetto base. Poi, procedete secondo le istruzioni contenute in
dh-make(1). Queste usano debhelper in
debian/rules.
Un approccio più datato è quello di usare deb-make dal pacchetto
debmake. Non usa nessuno script debhelper e dipende
esclusivamente dalla shell.
Per degli esempi di pacchetti con sorgenti multipli vedete "mc"
(dpkg-source -x mc_4.5.54.dsc), che usa "sys-build.mk"
di Adam Heath (doogie@debian.org) e
"glibc" (dpkg-source -x glibc_2.2.4-1.dsc), che usa un
altro sistema di Joel Klecker (espy@debian.org).
La guida Debian
1.08-3, dom mag 1 07:45:18 UTC 2005osamu@debian.orgdsewell@virginia.edumc0315@mclink.it