Tabla de contenidos
Algunos consejos para quién quiera aprender a programar en el sistema Debian para trazar el código fuente. Aquí están los paquetes más importantes y los paquetes de documentación más importantes para la programación.
Las referencia en línea está disponible escribiendo by typing «man
nombre
» tras instalar los paquetes manpages
y
manpages-dev
. La referencia en línea para las
herramientas GNU están disponibles escribiendo «info
nombre_de_programa
» después de instalar los paquetes
correspondientes de documentación. Pude necesitar incluir los repositorios
contrib
y non-free
además del
repositorio main
ya que una parte de la documentación
GFDL no se cosidera que cumple con DFSG.
Please consider to use version control system tools. See Sección 10.5, “Git”.
![]() |
Aviso |
---|---|
No use« |
![]() |
Atención |
---|---|
Usted puede instalar programas de software directametne compilado de la
fuente en « |
![]() |
Sugerencia |
---|---|
Los ejemplos de código para crear «La canción de 99 botellas de Cerveza« le aportará buenas ideas para pácticamente cualquier lenguaje de programación. |
Un archivo de órdenes es un archivo de texto co el bit de ejecución activado y contiene órdenes con el formato siguiente.
#!/bin/sh ... command lines
La primera línea determina cuál es el intérprete de órdenes que se encarga de leer y ejecutar el contenido del archivo.
La lectura de archivos de órdenes es la mejor manera de entender como funciona un sistema tipo Unix. Aquí, doy algunos apuntes para la programación de archivos de órdenes. Consulte «Errores con el intérprete de órdenes« (http://www.greenend.org.uk/rjk/2001/04/shell.html) para aprender los errores más comunes.
A diferencia del uso interactivo del intérprete de órdenes (consulte Sección 1.5, “Órdenes simples para el intérprete de órdenes” y Sección 1.6, “Operaciones de texto al estilo de Unix”) en los archivos de órdenes se usan generalmente parámetros, condiciones y bucles.
Many system scripts may be interpreted by any one of POSIX shells (see Tabla 1.13, “Relación de intérpretes de órdenes”).
The default non-interactive POSIX shell "/bin/sh
" is a
symlink pointing to /usr/bin/dash
and used by many system
programs.
The default interactive POSIX shell is /usr/bin/bash
.
Evite escribir archivos de órdenes con particularidades de bash o zs para
hacerlo portable entre intérpretes de órdenes POSIX. Puede comprobaro
utilizando checkbashisms
(1).
Tabla 12.1. Relación de particularidades de bash
Bien: POSIX | Mal: bashism |
---|---|
if [ «$foo« = «$bar« ] ; then … |
if [ «$foo« == «$bar« ] ; then … |
diff -u archivo.c.orig archivo.c |
diff -u archivo.c{.orig,} |
mkdir /foobar /foobaz |
mkdir /foo{bar,baz} |
funcname() { … } |
function funcname() { … } |
octal format: «\377 » |
formato hexadecimal: «\xff » |
La orden «echo
» debe utilizarse con cuidado ya que su
implementación cambia entre la orden interna y la externa.
Evite utilizar cualquier opción excepto -n
».
Evite utilizar secuencias de escape en una cadena ya que su tratamiento varia.
![]() |
Nota |
---|---|
Ya que la opción « |
![]() |
Sugerencia |
---|---|
Utilice la orden « |
Frecuentemente son utilizados por el intérprete de órdenes parámetros especiales
Tabla 12.2. Relación de los parámetros de intérprete de órdenes
parámetro del intérprete de órdenes | valor |
---|---|
$0 |
nombre del archivo de órdenes |
$1 |
primer parámetro del archivo de órdenes |
$9 |
noveno parámetro del archivo de órdenes |
$# |
parámetro posicionado en el número |
«$*« |
«$1 $2 $3 $4 … « |
«$@« |
«$1« «$2« «$3« «$4« … |
$? |
estado de finalización de la orden más reciente |
$$ |
PID de este archivo de órdenes |
$! |
PID del trabajo en segundo plano que se ha iniciado más recientemente |
Lasexpansiones de parámetros fundamentales que debe recordar son las que se muestran.
Tabla 12.3. Relación de expansiones de parámetros del intérprete de órdenes
forma de expresión del parámetro | valor si var esta activado |
valor si var no está asignado |
---|---|---|
${var:-string} |
«$var » |
«string » |
${var:+string} |
«string » |
«null » |
${var:=string} |
«$var » |
«string » (y ejecuta «var=string ») |
${var:?string} |
«$var » |
echo «string » a stderr
(y finalizar con error) |
Aquí, el símbolo «:
» en todos estos operadores es
realmente opcional.
con «:
» el operador =
comprueba que existe y no es null
sin «:
» el operador =
comprueba unicamente si existe
Tabla 12.4. Relación de las sustituciones clave de parámetros del intérprete de órdenes
formulario de sustitución del parámetro | resultado |
---|---|
${var%suffix} |
elimina patrón del sufijo más pequeño |
${var%%suffix} |
elimina el patrón del sufijo más largo |
${var#prefix} |
elimina el patrón del prefijo más pequeño |
${var##prefix} |
elimina el patrón del prefijo más largo |
Cada comando devuelve un estado de salida que puede usarse para expresioneos condicionales.
Éxito: 0 («Verdadero«)
Error: no 0 («Falso«)
![]() |
Nota |
---|---|
En el contexto del intérprete de órdenes «0« es equivalente a «verdadero«, mientras que en contexto de una condición en C «0« significa «falso«. |
![]() |
Nota |
---|---|
« |
Algunas expresiones condicionales que es importate recordar son las que se muestran.
«orden &&
si_éxito_ejecuta_esta_orden_además || true
»
«orden ||
si_no_tiene_éxito_ejecuta_esta_orden_además ||
true
»
Un pequeño archivo de órdenes de varias líneas como se muestra
if [ conditional_expression ]; then if_success_run_this_command else if_not_success_run_this_command fi
Aquí se añade «|| true
» para asegurarnos de que el
archivo de órdenes no finaliza en esta línea si el intérprete de órdenes se
llama con la bandera «-e
».
Tabla 12.5. Relación de operadores para comparar archivos en la expresión condicional
ecuación | condición que devuelve un verdadero lógico |
---|---|
-e archivo |
archivo existe |
-d archivo |
archivo existe y es un directorio |
-f archivo |
archivo existe y es un archivo normal |
-w archivo |
archivo existe y se puede modificar |
-x archivo |
archivo existe y es ejecutable |
archivo1 -nt
archivo2 |
archivo es más nuevo quearchivo2 (respecto de la modificación) |
archivo1 -ot
archivo2 |
archivo1 es más viejo que archivo2 (respecto de al modificación) |
archivo1 -ef
archivo2 |
archivo1 y archivo2 están en el mismo dispositivo y tienen el mismo número de inodo |
Tabla 12.6. Relación de operadores de comparación de cadenas en expresiones condicionales
ecuación | condición que devuelve un verdadero lógico |
---|---|
-z cadena_de_caracteres |
la longitud de str es cero |
-n cadena_de_caracteres |
la longitud de str no es cero |
cadena_de_caracteres1 =
cadena_de_caracteres2 |
cadena1 y cadena2 son iguales |
cadena_de_caracteres1 !=
cadena_de_caracteres2 |
str1 y str2 no son iguales |
cadena_de_caracteres1 <
cadena_de_caracteres2 |
cadena1 está antes que cadena2 (depende de la configuración regional) |
cadena_de_caracteres1 >
cadena_de_caracteres2 |
cadena1 está después de la cadena2 (depende de la configuración local) |
Los operadores aritméticos de comparación
de enteros en la expresión original son «-eq
»,
«-ne
», «-lt
»,
«-le
», «-gt
» y
«-ge
».
Existen diferentes bucles en el intérprete de órdenes POSIX.
«for x in foo1 foo2 … ; do comand0 ; done
» asigna
secuencialmente elementos de la relación «foo1 foo2 …
» a
la variable «x
» y ejecuta «comando
».
«while condición ; do comando ; done
» repite
«comando
» mientras «condición
» sea
verdadero.
«until condición ; do comando ; done
» repite
«comando
» mientras «condición
» no sea
verdadero.
«break
» permite salir del bucle.
«continue
» permite continuar con la próxima iteración del
bucle.
![]() |
Sugerencia |
---|---|
La iteración sobre números como la del lenguaje C
puede realizarse con la utilización de |
![]() |
Sugerencia |
---|---|
Consulta Sección 9.4.9, “Repetición de una orden sobre archivos”. |
Some popular environment variables for the normal shell command prompt may not be available under the execution environment of your script.
For "$USER
", use "$(id -un)
"
For "$UID
", use "$(id -u)
"
For "$HOME
", use "$(getent passwd "$(id -u)"|cut
-d ":" -f 6)
" (this works also on Sección 4.5.2, “La actual gestión centralizada de sistemas”)
El intérprete de órdenes ejecuta un archivo de órdenes siguiendo la secuencia que se muestra:
el intérprete de órdenes lee la línea
El intérprete de órdenes agrupa como un único
elemento la parte de la línea incluida entre
«…«
o '…'
.
el intérprete de órdenes divide el resto de la línea en elementos como se muestra.
Espacios en blanco: espacio
tabulador <nueva línea>
Metacharacters: | ; & ( )
El intérprete de órdenes comprueba si cada elemento es una palabra reservada para adaptar su comportamiento si
no esta incluida entre «…«
o '…'
.
palabras reservadas: if then
elif else fi for in while unless do done case esac
el intérprete de órdenes expande los alias si no están incluidos entre
«…«
o '…'
El intérprete de órdenes expande las tilde si no están incluidas entre
«…«
o '…'
.
«~
» → el directorio home del usuario actual
«~usuario
» → el directorio home de
usuario
el intérprete de órdenes expande los parámetros a sus valores si no están incluidos
entre '…'
parámetro:
«$PARAMETER
» o «${PARAMETER}
»
el intérprete de órdenes expande la sustitución de
órdenes si no está incluida entre '…'
«$( comando )
» → la salida de
«comando
»
«` comando `
» → la salida de «comando
»
el intérprete de órdenes expande las rutas de
nombres que encajan con nombres de archivos si no están incluidas
entre «…«
o '…'
*
→ cualesquier caracteres
?
→ un caracter
[…]
→ cualquiera de los caracteres en
«…
»
el intérprete de órdenes busca las órdenes como se muestra y los ejecuta
definición de lafunción
orden interna
archivo ejecutable en
«$PATH
»
el intérprete de órdenes va a la siguiente línea y repite este proceso de nuevo desde el inicio de la secuencia
Las comillas simples no tienen efecto dentro de comillas dobles.
Si ejecuta «set -x
» en el intérprete de órdenes o lo
llama con la opción «-x
» hace que se impriman todas las
órdenes ejecutadas. Esto puede ser muy útil para la depuración.
Para hacer los archivos de órdenes tan portables como sea posible entre sistemas Debian, es una buena idea limitar las utilidades a aquellos que son proporcionados por los paquetes esenciales.
«aptitude search ~E
» relación paquetes esenciales.
«dpkg -L paquete | grep
'/man/man.*/'
» relación páginas de manual de las órdenes del
paquete paquete
.
Tabla 12.7. Relación de paquetes que contienen pequeñas utilidades para los archivos de órdenes
paquete | popularidad | tamaño | descripción |
---|---|---|---|
dash
|
V:894, I:995 | 191 | small and fast POSIX-compliant shell for sh |
coreutils
|
V:908, I:999 | 18062 | Utilidades fundamentales GNU |
grep
|
V:799, I:999 | 1245 | GNU grep , egrep and
fgrep |
sed
|
V:792, I:999 | 987 | GNU sed |
mawk
|
V:391, I:997 | 263 | small and fast awk |
debianutils
|
V:919, I:999 | 243 | utilidades varias específicas de Debian |
bsdutils
|
V:610, I:999 | 355 | utilidades básicas de BSD-Lite 4.4 |
bsdextrautils
|
V:454, I:548 | 337 | extra utilities from 4.4BSD-Lite |
moreutils
|
V:14, I:39 | 244 | utilidades adicionales de Unix |
![]() |
Sugerencia |
---|---|
Although |
See Sección 1.6, “Operaciones de texto al estilo de Unix” for examples.
Tabla 12.8. List of interpreter related packages
paquete | popularidad | tamaño | documentación |
---|---|---|---|
dash
|
V:894, I:995 | 191 | sh: small and fast POSIX-compliant shell for
sh |
bash
|
V:821, I:999 | 7163 | sh: "info bash " provided by
bash-doc |
mawk
|
V:391, I:997 | 263 | AWK: small and fast awk |
gawk
|
V:313, I:402 | 2456 | AWK: "info gawk " provided by
gawk-doc |
perl
|
V:644, I:990 | 669 | Perl: perl (1) and html pages
provided by perl-doc and perl-doc-html |
libterm-readline-gnu-perl
|
V:2, I:30 | 379 | Perl extension for the GNU ReadLine/History Library:
perlsh (1) |
libreply-perl
|
V:0, I:0 | 171 | REPL for Perl: reply (1) |
libdevel-repl-perl
|
V:0, I:0 | 237 | REPL for Perl: re.pl (1) |
python3
|
V:726, I:931 | 80 | Python: python3 (1) and html
pages provided by python3-doc |
tcl
|
V:28, I:268 | 22 | Tcl: tcl (3) and detail manual
pages provided by tcl-doc |
tk
|
V:22, I:261 | 22 | Tk: tk (3) and detail manual
pages provided by tk-doc |
ruby
|
V:112, I:254 | 29 | Ruby: ruby (1),
erb (1), irb (1),
rdoc (1), ri (1) |
When you wish to automate a task on Debian, you should script it with an interpreted language first. The guide line for the choice of the interpreted language is:
Use dash
, if the task is a simple one which combines CLI
programs with a shell program.
Use python3
, if the task isn't a simple one and you are
writing it from scratch.
Use perl
, tcl
,
ruby
, ... if there is an existing code using one of these
languages on Debian which needs to be touched up to do the task.
If the resulting code is too slow, you can rewrite only the critical portion for the execution speed in a compiled language and call it from the interpreted language.
Most interpreters offer basic syntax check and code tracing functionalities.
“dash -n script.sh” - Syntax check of a Shell script
“dash -x script.sh” - Trace a Shell script
“python -m py_compile script.py” - Syntax check of a Python script
“python -mtrace --trace script.py” - Trace a Python script
“perl -I ../libpath -c script.pl” - Syntax check of a Perl script
“perl -d:Trace script.pl” - Trace a Perl script
For testing code for dash
, try Sección 9.1.4, “Readline wrapper” which accommodates
bash
-like interactive environment.
For testing code for perl
, try REPL environment for Perl
which accommodates Python-like REPL (=READ + EVAL + PRINT + LOOP)
environment for Perl.
The shell script can be improved to create an attractive GUI program. The
trick is to use one of so-called dialog programs instead of dull interaction
using echo
and read
commands.
Tabla 12.9. List of dialog programs
paquete | popularidad | tamaño | descripción |
---|---|---|---|
x11-utils
|
V:169, I:556 | 712 | xmessage (1): muestra un mensaje o realiza un pregunta en
una ventana(X) |
whiptail
|
V:258, I:996 | 57 | muestra cuadros de diálogo de fácil uso para los archivos de órdenes (newt) |
dialog
|
V:13, I:113 | 1213 | muestra cuadros de diálogo de fácil uso para los archivos de órdenes (ncurses) |
zenity
|
V:74, I:356 | 167 | display graphical dialog boxes from shell scripts (GTK) |
ssft
|
V:0, I:0 | 75 | Herramienta de interfaz de archivo de órdenes (cubierto con zenity, kdialog y dialog con gettext) |
gettext
|
V:55, I:278 | 5825 | «/usr/bin/gettext.sh »: traduce un mensajes |
Here is an example of GUI program to demonstrate how easy it is just with a shell script.
This script uses zenity
to select a file (default
/etc/motd
) and display it.
GUI launcher for this script can be created following Sección 9.4.10, “Iniciar un programa desde el interfaz gráfico de usuario”.
#!/bin/sh -e # Copyright (C) 2021 Osamu Aoki <osamu@debian.org>, Public Domain # vim:set sw=2 sts=2 et: DATA_FILE=$(zenity --file-selection --filename="/etc/motd" --title="Select a file to check") || \ ( echo "E: File selection error" >&2 ; exit 1 ) # Check size of archive if ( file -ib "$DATA_FILE" | grep -qe '^text/' ) ; then zenity --info --title="Check file: $DATA_FILE" --width 640 --height 400 \ --text="$(head -n 20 "$DATA_FILE")" else zenity --info --title="Check file: $DATA_FILE" --width 640 --height 400 \ --text="The data is MIME=$(file -ib "$DATA_FILE")" fi
This kind of approach to GUI program with the shell script is useful only for simple choice cases. If you are to write any program with complexities, please consider writing it on more capable platform.
GUI filer programs can be extended to perform some popular actions on selected files using additional extension packages. They can also made to perform very specific custom actions by adding your specific scripts.
For GNOME, see NautilusScriptsHowto.
For KDE, see Creating Dolphin Service Menus.
For Xfce, see Thunar - Custom Actions and https://help.ubuntu.com/community/ThunarCustomActions.
For LXDE, see Custom Actions.
In order to process data, sh
needs to spawn sub-process
running cut
, grep
,
sed
, etc., and is slow. On the other hand,
perl
has internal capabilities to process data, and is
fast. So many system maintenance scripts on Debian use
perl
.
Let's think following one-liner AWK script snippet and its equivalents in Perl.
awk '($2=="1957") { print $3 }' |
Esto es equivalente a cualquiera de las siguientes líneas.
perl -ne '@f=split; if ($f[1] eq "1957") { print "$f[2]\n"}' |
perl -ne 'if ((@f=split)[1] eq "1957") { print "$f[2]\n"}' |
perl -ne '@f=split; print $f[2] if ( $f[1]==1957 )' |
perl -lane 'print $F[2] if $F[1] eq "1957"' |
perl -lane 'print$F[2]if$F[1]eq+1957' |
El último es retorcido. Utiliza algunas de las funcionalidades avanzadas de Perl.
El espacio en blanco es opcional.
La conversión entre números y cadenas se realiza de forma automática.
Perl execution tricks via command line options:
perlrun
(1)
Perl special variables: perlvar
(1)
This flexibility is the strength of Perl. At the same time, this allows us to create cryptic and tangled codes. So be careful.
For more crazy Perl scripts, Perl Golf may be interesting.
Tabla 12.10. List of compiler related packages
paquete | popularidad | tamaño | descripción |
---|---|---|---|
gcc
|
V:153, I:565 | 47 | GNU C compiler |
libc6-dev
|
V:246, I:581 | 11954 | GNU C Library: Development Libraries and Header Files |
g++
|
V:56, I:503 | 14 | GNU C++ compiler |
libstdc++-10-dev
|
V:38, I:269 | 17587 | GNU Standard C++ Library v3 (development files) |
cpp
|
V:317, I:727 | 30 | GNU C preprocessor |
gettext
|
V:55, I:278 | 5825 | GNU Internationalization utilities |
glade
|
V:0, I:6 | 1209 | GTK User Interface Builder |
valac
|
V:0, I:5 | 717 | C# like language for the GObject system |
flex
|
V:8, I:82 | 1260 | LEX-compatible fast lexical analyzer generator |
bison
|
V:8, I:89 | 3116 | YACC-compatible parser generator |
susv2
|
I:0 | 16 | cumple «La Especificación Única de UNIX v2« |
susv3
|
I:0 | 16 | cumple «La Especificación Única de UNIX v3« |
golang
|
I:20 | 12 | Go programming language compiler |
rustc
|
V:3, I:13 | 7753 | Rust systems programming language |
haskell-platform
|
I:4 | 12 | Standard Haskell libraries and tools |
gfortran
|
V:8, I:75 | 16 | GNU Fortran 95 compiler |
fpc
|
I:3 | 102 | Free Pascal |
Here, Sección 12.3.3, “Flex — una mejora de Lex” and Sección 12.3.4, “Bison — una mejora de Yacc” are included to indicate how compiler-like program can be written in C language by compiling higher level description into C language.
Puede configurar su entorno para la compilación de programas escritos en el lenguaje de programación C como se muestra.
# apt-get install glibc-doc manpages-dev libc6-dev gcc build-essential
El paquete libc6-dev
, a saber, la biblioteca GNU C,
aporta la biblioteca estándar de C
que es un conujnto de archivos de cabecera y rutinas de biblioteca
utilizadas por el lenguaje de programación C.
Consulte las referencias siguientes sobre C.
«info libc
» (referencia de las funciones de la biblioteca
de C)
gcc
(1) y «info gcc
»
nombre_de_cada_función_de_la_biblioteca_de_C
(3)
Kernighan & Ritchie, «The C Programming Language«, 2nd edición (Prentice Hall)
Se puede crear un ejecutable «ejecutable_de_ejemplo
»
utilizando la biblioteca «libm
» mediante este sencillo
ejemplo.
$ 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
Aquí, se necesita «-lm
» para enlazar la biblioteca
«/usr/lib/libm.so
» del paquete libc6
para utilizar la función sqrt
(3). La biblioteca real
está ubicada en «/lib/
» con el nombre de archivo
«libm.so.6
», el cual es un enlace simbólico a
«libm-2.7.so
».
Mire el último elemento de la salida. Tiene incluso más de 10 caracteres a
pesar de tener «%10s
».
La utilización de operaciones de punteros sin comprobar los límites, como
ocurre con sprintf
(3) y strcpy
(3), no
se utilizan para evitar el desbordamiento del buffer que puede provocar
problemas desconocidos. En su lugar se utilizan
snprintf
(3) y strncpy
(3).
Flex es un generador rápido de analizadores léxicos compatible con Lex.
Puede encontrar un tutuorial de flex
(1) en «info
flex
».
Necesita que proporcione su propio «main()
» y
«yywrap()
». De otra manera su programa flex se parecerá a
este al compilarlo sin la biblioteca. Esto es debido a que
«yywrap
» es una macro y «%option main
»
se combierte implicitamente en «%option noyywrap
».
%option main %% .|\n ECHO ; %%
También puede compilar con la opción de enlazado «-lfl
»
al final de su línea de órdenes cc
(1) (como AT&T-Lex
con «-ll
»). En ese caso no es necesaria la opción
«%option
».
Los paquetes que proporcionan un mejor y compatible Yacc son el analizador sintáctico LR o el analizador sintáctico LALR de Debian.
Puede encontrar un tutorial de bison
(1) en
«info bison
».
Puede que sea necesario que proporcione su propio
«main()
» y «yyerror()
». El método
«main()
» invoca «yyparse()
» el cual
invoca «yylex()
», que normalmente se crea con Flex.
%% %%
Lint like tools can help automatic static code analysis.
Indent like tools can help human code reviews by reformatting source codes consistently.
Ctags like tools can help human code reviews by generating an index (or tag) file of names found in source codes.
![]() |
Sugerencia |
---|---|
Configuring your favorite editor ( |
Tabla 12.12. Relación de las herramientras para el análisis de código estático
paquete | popularidad | tamaño | descripción |
---|---|---|---|
vim-ale
|
I:0 | 2591 | Asynchronous Lint Engine for Vim 8 and NeoVim |
vim-syntastic
|
I:3 | 1379 | Syntax checking hacks for vim |
elpa-flycheck
|
V:0, I:1 | 792 | modern on-the-fly syntax checking for Emacs |
elpa-relint
|
V:0, I:0 | 135 | Emacs Lisp regexp mistake finder |
cppcheck-gui
|
V:0, I:1 | 6196 | tool for static C/C++ code analysis (GUI) |
shellcheck
|
V:2, I:11 | 18987 | lint tool for shell scripts |
pyflakes3
|
V:1, I:14 | 24 | passive checker of Python 3 programs |
pylint
|
V:4, I:17 | 1976 | comprobador de código estático Python |
perl
|
V:644, I:990 | 669 | intérprete con comprobador de código estático interno:
B::Lint (3perl) |
rubocop
|
V:0, I:0 | 3247 | Ruby static code analyzer |
clang-tidy
|
V:1, I:8 | 21 | clang-based C++ linter tool |
splint
|
V:0, I:3 | 2320 | herramienta para la comprobación estática de errores de programación en C |
flawfinder
|
V:0, I:0 | 205 | herramienta que examina código fuente en C/C++ para encontrar debilidades de seguridad |
black
|
V:2, I:8 | 557 | uncompromising Python code formatter |
perltidy
|
V:0, I:4 | 2338 | Perl script indenter and reformatter |
indent
|
V:0, I:9 | 426 | C language source code formatting program |
astyle
|
V:0, I:3 | 761 | Source code indenter for C, C++, Objective-C, C#, and Java |
bcpp
|
V:0, I:0 | 111 | C(++) beautifier |
xmlindent
|
V:0, I:1 | 53 | XML stream reformatter |
global
|
V:1, I:2 | 1896 | Source code search and browse tools |
exuberant-ctags
|
V:3, I:25 | 345 | build tag file indexes of source code definitions |
Debug is important part of programming activities. Knowing how to debug programs makes you a good Debian user who can produce meaningful bug reports.
El principal depurador en Debian es
gdb
(1) el cual permite inspeccionar un programa mientras
se ejecuta.
Instalemo gdb
y otros programas relevantes com se
muestra.
# apt-get install gdb gdb-doc build-essential devscripts
Good tutorial of gdb
can be found:
“info gdb
”
“Debugging with GDB” in
/usr/share/doc/gdb-doc/html/gdb/index.html
Here is a simple example of using gdb
(1) on a
"program
" compiled with the "-g
"
option to produce debugging information.
$ gdb program (gdb) b 1 # set break point at line 1 (gdb) run args # run program with args (gdb) next # next line ... (gdb) step # step forward ... (gdb) p parm # print parm ... (gdb) p parm=12 # set value to 12 ... (gdb) quit
![]() |
Sugerencia |
---|---|
Existen abreviaturas para la mayor parte de las órdenes de
|
Since all installed binaries should be stripped on the Debian system by
default, most debugging symbols are removed in the normal package. In order
to debug Debian packages with gdb
(1),
*-dbgsym
packages need to be installed
(e.g. coreutils-dbgsym
in the case of
coreutils
). The source packages generate
*-dbgsym
packages automatically along with normal binary
packages and those debug packages are placed separately in debian-debug archive. Please refer to articles on Debian Wiki for more
information.
If a package to be debugged does not provide its *-dbgsym
package, you need to install it after rebuilding it by the following.
$ mkdir /path/new ; cd /path/new $ sudo apt-get update $ sudo apt-get dist-upgrade $ sudo apt-get install fakeroot devscripts build-essential $ apt-get source package_name $ cd package_name* $ sudo apt-get build-dep ./
Si lo necesita corrija los errores.
Cuando recompile la publicación de un paquete ya existente elija una que no
exista en Debian, p. ej. añadiendole «+debug1
» o
añadiendole «~pre1
» como se muestra.
$ dch -i
Para compilar e instalar paquetes con la depuración de símbolos activada realice las siguientes operaciones:
$ export DEB_BUILD_OPTIONS="nostrip noopt" $ debuild $ cd .. $ sudo debi package_name*.changes
Necesita comprobar que los archivos de órdenes del paquete y utlizar
«CFLAGS=-g -Wall
» para la compilación de binarios.
Cuando encuentre un programas que no funciona, es una buena idea al informar del error añadir información sobre las trazas de su ejecución.
The backtrace can be obtained by gdb
(1) using one of the
following approaches:
Crash-in-GDB approach:
Run the program from GDB.
Crash the program.
Type "bt
" at the GDB prompt.
Crash-first approach:
Update the “/etc/security/limits.conf” file to include the following:
* soft core unlimited
Type "ulimit -c unlimited
" to the shell prompt.
Run the program from this shell prompt.
Crash the program to produce a core dump file.
Load the core dump file to GDB as
"gdb gdb ./program_binary core
" .
Type "bt
" at the GDB prompt.
For infinite loop or frozen keyboard situation, you can force to crash the
program by pressing Ctrl-\
or Ctrl-C
or executing “kill -ABRT PID
”. (See
Sección 9.4.12, “Matando un proceso”)
![]() |
Sugerencia |
---|---|
Frecuentemente encontrará en primeras líneas « $ MALLOC_CHECK_=2 gdb hello |
Tabla 12.14. Relación de órdenes avanzadas gdb
orden | descripción de la funcionalidad de la orden |
---|---|
(gdb) hilo aplica a todos bt |
recogen trazas de todos los hilos para programas multihilo |
(gdb) bt full |
recoge los parámetros de la pila de las llamadas de función |
(gdb) thread apply all bt full |
recoge trazas y parámetros como una combinación de las opciones anteriores |
(gdb) thread apply all bt full 10 |
recoge trazas y parámetros de las 10 llamadas más recientes para eliminar información no relevante |
(gdb) set logging on |
escribe la salida del registro de gdb a un archivo (por
defecto «gdb.txt ») |
Utilice como se muestra ldd
(1) para determinar las
bibliotecas de las que depende un programa.
$ 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)
Para que ls
(1) funcione en un entorno `chroot` las
bibliotecas siguientes deben estar disponibles en dicho entorno.
Consulte Sección 9.4.6, “Trazando la actividad de un programa”.
There are several dynamic call tracing tools available in Debian. See Sección 9.4, “Monitoreando, controlando e iniciando lo que hacer los programas”.
Si el programa GNOME preview1
ha recibido un error de las
X se puede ver el mensaje como se muestra.
The program 'preview1' received an X Window System error.
En este caso, puede intentar ejecutar el programa con
«--sync
», y poner un punto de ruptura en la función
«gdk_x_error
» con el fin de obtener trazas.
Existen varias herramientas de detección de fugas de memoria en Debian.
Tabla 12.15. Relación de herramientas de detección de fugas de memoria
paquete | popularidad | tamaño | descripción |
---|---|---|---|
libc6-dev
|
V:246, I:581 | 11954 | mtrace (1): funcionalidad de depuración de malloc en glibc |
valgrind
|
V:6, I:38 | 77683 | depurador y analizador de memoria |
electric-fence
|
V:0, I:4 | 73 | depurador malloc (3) |
libdmalloc5
|
V:0, I:3 | 393 | biblioteca de depuración de la asignación de memoria |
duma
|
V:0, I:0 | 293 | library to detect buffer overruns and under-runs in C and C++ programs |
leaktracer
|
V:0, I:2 | 56 | programas C++ para trazar fugas de memoria |
Tabla 12.16. List of build tool packages
paquete | popularidad | tamaño | documentación |
---|---|---|---|
make
|
V:147, I:574 | 1592 | «info make » proporcionado por make-doc |
autoconf
|
V:33, I:257 | 2025 | «info autoconf » proporcionado con
autoconf-doc |
automake
|
V:34, I:256 | 1837 | «info automake » proporcionado con
automake1.10-doc |
libtool
|
V:29, I:240 | 1213 | "info libtool " provided by libtool-doc |
cmake
|
V:16, I:116 | 28897 | cmake (1) cross-platform, open-source make system |
ninja-build
|
V:5, I:34 | 417 | ninja (1) small build system closest in spirit to Make |
meson
|
V:2, I:20 | 3451 | meson (1) high productivity build system on top of
ninja |
xutils-dev
|
V:1, I:10 | 1485 | imake (1), xmkmf (1), etc. |
Make es una utilidad para mantener grupos de
programas. is a utility to maintain groups of programs. La ejecución de
make
(1) consiste en, la lectura del archivo de reglas
«Makefile
» por parte de make
y la
actualización de un objetivo si los archivos que son necesarios han sido
modificados desde la última vez o si el objetivo no existe. La ejecución de
estas actualizaciones pueden suceder de concurrentemente.
La sintáxis del archivo de reglas es la que se muestra.
target: [ prerequisites ... ] [TAB] command1 [TAB] -command2 # ignore errors [TAB] @command3 # suppress echoing
Aquí «[TAB]
» es un código TAB. Cada línea es interpretada
por el intérprete de órdenes después de la sustitución de las
variables. Utilice «\
» al final de la líena para
continuar el archivo de órdenes. Utilice «$$
» para
incluir «$
» par los valores del entorno para el archivo
de órdenes.
Las reglas implícitas y los prerequisitos para un objetivos pueden ser escrito, por ejemplo, como se muestra.
%.o: %.c header.h
Aquí, el objetivo contiene el carácter «%
» (únicamente un
carácter). El carácter %
» encaja con cualquier cadena no
vacía que corresponda a los nombres de archivo del objetivo real. Así mismo
el prerrequisito utiliza «%
» para mostrar como se
relaciones sus nombres con los nombres del objetivo real.
Tabla 12.17. Relación de variables automáticas de make
variable automática | valor |
---|---|
$@ |
objetivo |
$< |
primer prerrequisitos |
$? |
todos los prerrequisitos nuevos |
$^ |
todos los prerequisitos |
$* |
«% » encaja la raíz en el patrón del objetivo |
Tabla 12.18. Relación de expansiones de variables de make
expansión variable | descripción |
---|---|
foo1 := bar |
expansión por única vez |
foo2 = bar |
expansión recursiva |
foo3 += bar |
anexar |
Ejecute «make -p -f/dev/null
»para ver las reglas internas
automática.
Autotools is a suite of programming tools designed to assist in making source code packages portable to many Unix-like systems.
Autoconf is a tool to produce a shell script
"configure
" from "configure.ac
".
"configure
" is used later to produce
"Makefile
" from "Makefile.in
"
template.
Automake is a tool to produce
"Makefile.in
" from "Makefile.am
".
Libtool is a shell script to address the software portability problem when compiling shared libraries from source code.
![]() |
Aviso |
---|---|
Cuando compile programas y los instale no sobreescriba los archivos del sistema. |
Debian no modifica los archivos en «/usr/local/
» o
«/opt
». Así que si compila un programa desde el código
fuente, instaleló en «/usr/local/
» para que no interfiera
con Debian.
$ cd src $ ./configure --prefix=/usr/local $ make # this compiles program $ sudo make install # this installs the files in the system
Si se tiene el código original, se utiliza
autoconf
(1)/automake
(1) y se recuerda
como se configuró, ejecute lo siguiente para realizar la desistalación del
programa.
$ ./configure all-of-the-options-you-gave-it
$ sudo make uninstall
Otra manera, si está totalmente seguro de que la instalación solo únicamente
archivos en «/usr/local/
» y no hay nada importante allí,
puede borrar todo su contenido como se muestra.
# find /usr/local -type f -print0 | xargs -0 rm -f
If you are not sure where files are installed, you should consider using
checkinstall
(8) from the checkinstall
package, which provides a clean path for the uninstall. It now supports to
create a Debian package with "-D
" option.
The software build system has been evolving:
Autotools on the top of Make has been the de facto standard for the portable build infrastructure since 1990s. This is extremely slow.
CMake initially released in 2000 improved speed significantly but was still build on the top of inherently slow Make.
Ninja initially released in 2012 is meant to replace Make for the further improved build speed but is also designed to have its input files generated by a higher-level build system.
Meson initially released in 2013 is the new popular and fast higher-level build system which uses Ninja as its backend.
See documents found at "The Meson Build system" and "The Ninja build system".
Se pueden crear páginas web dinámicas básicas como se muestra.
Las consultas se presentan al navegador del usuario utilizando formularios HTML.
Rellenando y pulsado sobre las entradas del formulario se envia la cadena URL con los parámetros codificados desde el navegador al servidor web.
«http://www.foo.dom/cgi-bin/program.pl?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
»
«http://www.foo.dom/cgi-bin/program.py?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
»
«http://www.foo.dom/program.php?VAR1=VAL1&VAR2=VAL2&VAR3=VAL3
»
«%nn
» en la URL se sustituye por el carácter hexadecimal
que tiene el valor nn
.
Las variables de entorno se asignan como: «QUERY_STRING=«VAR1=VAL1
VAR2=VAL2 VAR3=VAL3«
».
Un programa CGI (independientemente de su
extensión «programa.*
») en un servidor web se ejecuta a
si mimo con la variable de entorno «$QUERY_STRING
».
La salida
de un programa CGI se envía al servidor web y
se representa como una página web dinámica.
Por seguridad es mejor no realizar de forma manual o de otras formas la gestión de análisis de los parámetros CGI. Existen módulos para ello en Perl y Python. PHP tiene dicha funcionalidad. Cuando se necesita almacenar información del usuario, se utilizan las cookies HTTP cookies. Cuando se necesita procesar información en el lado del cliente, normalmente se utiliza Javascript.
Para mayor información, consulteInterfaz de Pasarela Común (Common Gateway Interface), La Fundación de Software Apache (The Apache Software Foundation) y JavaScript.
Buscar «CGI tutorial« en Google, escribiendo la URL codificada http://www.google.com/search?hl=en&ie=UTF-8&q=CGI+tutorial directamente en la barra de direcciones del navegador, es una buena manera de ver en acción un archivo de órdenes en el servidor G¡de Google.
Existen aplicaciones para convertir código fuente de un lenguaje a otro.
Tabla 12.19. Relación de herramientas de traducción de código fuente
paquete | popularidad | tamaño | palabra clave | descripción |
---|---|---|---|---|
perl
|
V:644, I:990 | 669 | AWK→PERL | converit código fuente de AWK a PERL: a2p (1) |
f2c
|
V:0, I:4 | 442 | FORTRAN→C | convierte código fuente de FORTRAN 77 a C/C++: f2c (1) |
intel2gas
|
V:0, I:0 | 178 | intel→gas | convierte de NASM (formato Intel) a GAS (Ensamblador GNU) |
Si quiere hacer un paquete Debian, lea lo siguiente.
Capítulo 2, Gestión de paquetes Debian para comprender los fundamentos del sistema de paquetes
Sección 2.7.13, “Portar un paquete a un sistema estable” para comprender lo fundamental del proceso de portabilidad
Sección 9.11.4, “Sistemas chroot” para comprender los fundamentos de la técnica de chroot
debuild
(1), and sbuild
(1)
Sección 12.5.2, “Depurando un paquete Debian” para la recompilación con la finalidad de la depuración
Guía de Mantenedores Debian (Guide
for Debian Maintainers) (el paquete debmake-doc
)
Referencia de Desarrolladores de
Debian (Debian Developer's Reference) (en el paquete
developers-reference
)
Manual Directrices de Debian (en
el paquete debian-policy
)
Existen paquetes que ayudan al empaquetado como debmake
,
dh-make
, dh-make-perl
, etc.