Ubuntu entrada (3) Compilador GCC Makefile basado en la programación Shall

1.GCC compilador

1.1. Configuración de VIM

1. Abra el archivo / etc / vim / vimrc con vi y configure la tecla TAB en 4 espacios: configure ts = 4.
2. Establezca el número de línea de la pantalla: configure nu.
3. "Esc" + ":" + "q guardar y salir.

1.2 Código compilado

Verifique la versión de gcc: gcc -v.
Comando de compilación: gcc xxx.c -o xxx
opciones principales:

proceso de compilación: preprocesamiento, compilación, ensamblaje y vinculación. El preprocesamiento es expandir todos los archivos de encabezado, reemplazar las macros en el programa, analizar la compilación condicional y agregar al archivo. La compilación es la compilación de código precompilado en código ensamblador, que es lo que a menudo decimos sobre la compilación de programas. El ensamblaje consiste en compilar archivos de lenguaje ensamblador en archivos de objetos binarios. Vincular
es vincular los múltiples objetivos binarios compilados para formar el archivo ejecutable final. Al vincular, las bibliotecas estáticas y las bibliotecas dinámicas también estarán involucradas. Puede usar el comando gcc para generar un archivo ejecutable sin primero compilar el archivo c en un archivo .o y luego vincularlo.

2. Conceptos básicos de Makefile

2.1. Procedimientos experimentales

Hay 5 archivos en el experimento: main.c, input.c, calcu.c, input.h, calcu.h.

//main.c
#include <stdio.h>
#include "input.h"
#include "calcu.h"
int main(int argc, char *argv[])
{
	int a, b, num;
	input_int(&a, &b);
	num = calcu(a, b);
	printf("%d + %d = %d\r\n", a, b, num);
}

//input.c
#include <stdio.h>
#include "input.h"
void input_int(int *a, int *b)
{
	printf("input two num:");
	scanf("%d %d", a, b);
	printf("\r\n");
}

//calcu.c
#include "calcu.h"
int calcu(int a, int b)
{
	return (a + b);
}

//input.h
#ifndef _INPUT_H
#define _INPUT_H
void input_int(int *a, int *b);
#endif

//calcu.h
#ifndef _CALCU_H
#define _CALCU_H
int calcu(int a, int b);
#endif

La función del experimento es obtener los dos números ingresados ​​por el teclado e imprimir la suma de ellos. Los parámetros de la función input_int son dos variables de puntero de tipo int. Al llamar, deben definirse dos números de tipo int, y sus direcciones se utilizan como parámetros de entrada de la función. Ingrese el comando "gcc main.c calcu.c input.c -o main" para compilar y vincular, y luego use "./main" para ejecutar, pero la desventaja es que el comando gcc necesita ingresar todos los nombres de archivos c y modificar uno Todos los archivos deben ser recompilados.

2.2 Concepto de Makefile y pasos básicos de operación

Makefile características:

1. Si el proyecto no se ha compilado, todos los archivos .c del proyecto deben compilarse y vincularse a un programa ejecutable.
2. Si solo se modifican unos pocos archivos C en el proyecto, solo compile los archivos C modificados.
3. Si se modifica el archivo de encabezado del proyecto, todos los archivos C que hacen referencia a este archivo de encabezado deben compilarse y vincularse en un archivo ejecutable.

Pasos de la operación:

1. Cree un archivo llamado "Makefile" en el directorio del proyecto.
2. Modifique / etc / vim / vimrc.
   
3. Escriba el archivo Makefile, la sangría debe usar "Tab".
4. Ingrese el comando "make" para compilar y vincular el archivo.

2.3. Formato de regla de Makefile

Formato de regla:
destino ...: conjunto de archivos dependiente ...
Comando 1
Comando 2 ... El
comando make creará un proceso Shell para cada comando en el Makefile que comienza con TAB para ejecutarse.

Análisis de las reglas de contenido del archivo Makefile:

1. Actualice el principal en la primera regla, donde el objetivo se convierte en el objetivo predeterminado, siempre que el objetivo predeterminado se actualice, se considera que el trabajo de Makefile se ha completado. La primera regla se ejecutará porque main todavía no existe durante la primera compilación. La primera regla depende de los tres archivos principales .o, input.o y calcu.o. Actualmente no hay archivos .o, por lo que debe ser Actualice estos tres archivos primero. make encontrará y ejecutará las reglas dirigidas a estos tres archivos .o.
2. Tomando main.o como ejemplo, se encuentra que es la segunda regla actualizar main.o, por lo que se ejecutará la segunda regla. El comando en la segunda regla es "gcc -c main.c", que compila main.c, Generar main.o.
3. Cuando se ejecuta la primera regla, cuando se encuentra que el archivo de destino existe o el archivo del que depende el destino no es más nuevo que el archivo de destino (es decir, el último tiempo de modificación es anterior al archivo de destino), el comando de compilación posterior no se ejecutará.
4. El último objetivo de la regla es limpio, no tiene archivos dependientes, por lo que, por defecto, los archivos dependientes están actualizados y no ejecutarán los comandos correspondientes. Si desea ejecutar clean, puede usar directamente el comando "make clean".

2.4. Variables Makefile

1. $ (Nombre de la variable): el método de referencia de la variable en el Makefile es "$ (nombre de la variable)". La siguiente figura usa "=" al asignar objetos variables.
   
2. ** Asignación "=": Al usar "=" para asignar una variable, con la ayuda de otra variable, puede empujar el valor real de la variable hacia atrás para definir, es decir, el valor real de la variable depende de a qué se refiere El último valor válido de la variable. Use "echo" en el carácter de salida de Makefile, al igual que "printf" en C, y agregue "@" al frente no generará el proceso de ejecución del comando.
   
   
3. Carácter de asignación ": =": no se usarán las variables definidas más adelante, solo se usarán las ya definidas anteriormente.
   
   
4. Carácter de asignación "? =": Si la variable no se ha asignado antes, entonces la variable es igual al valor después de "? =", Si el valor se ha asignado antes, se utiliza el valor asignado antes.
5. Agregue "+ =" a la variable : la variable en el Makefile es una cadena. A veces necesita agregar algunas cadenas a la variable previamente definida, debe usar "+ =".

2.5 Reglas de modo Makefile y variables de automatización

Formato:%

.o :% .c (Tabulador) Comando Puede usar una regla para compilar todos los archivos .c en los archivos .o correspondientes utilizando las reglas de modo. El "%" en el destino indica una coincidencia con el nombre del archivo, y el "%" indica una cadena no vacía de cualquier longitud. Por ejemplo, "% .c" son todos los archivos que terminan en .c. "A.%. C" significa todos los archivos que comienzan con a. Y terminan con .c.

Variables de automatización: en las reglas de patrón mencionadas anteriormente, cada vez que se analizan las reglas de patrón, serán diferentes objetivos y archivos dependientes, y el comando solo tiene una línea. Utilice variables de automatización para generar objetivos correspondientes a partir de diferentes archivos dependientes con una línea de comandos. La llamada variable de automatización es que eliminará automáticamente una serie de archivos definidos en el patrón uno por uno. Las variables de automatización solo deben aparecer en el comando de la regla. Las variables de automatización utilizadas comúnmente son las siguientes: Después de

usar el modo de regla y las variables de automatización, el Makefile se puede modificar para:

2.6. Sentencia de condición de archivo

Formato de sintaxis:

<条件关键字>
	<条件为真时执行的语句>
endif
//以及
<条件关键字>
	<条件为真时执行的语句>
else
	<条件为假时执行的语句>
endif

4 palabras clave: ifeq, ifneq, ifdef e ifndef.

3. Deberá programar

3.1. Lo básico del script

Introducción: el script de shell es un archivo de texto sin formato, ejecutado línea por línea, la extensión del script de shell es .sh y la primera línea debe ser "#! / Bin / bash" .

Script de shell interactivo (Experimento 1): cuando el
script de shell se escribe y ejecuta, se descubre que los permisos no son suficientes. Use "ls xxx.sh -l" para encontrar que el archivo de script no tiene permisos ejecutables, así que use el comando chmod para abrir todos los permisos del archivo de script. Se puede ejecutar normalmente.


Cálculo numérico del script de shell (Experimento 2): el shell solo admite la configuración y el cálculo numérico usa $ ((expresión)). Tenga en cuenta que no puede agregar un signo igual después del total.

comando de prueba (Experimento 3):

1. El comando de prueba se usa para verificar si el archivo existe, así como los permisos y otra información, y se puede probar en tres aspectos: descripción del trabajo, caracteres y archivos
2. Comando &&: cmd1 && cmd, cmd2 solo se puede ejecutar después de que cmd1 se ejecute correctamente; si cmd1 se ejecuta incorrectamente, cmd2 no se ejecuta.
3. || Comando: cuando cmd1 se ejecuta correctamente, cmd2 no se ejecuta; si cmd1 se ejecuta incorrectamente, cmd2 se ejecuta.

En el ejemplo a continuación, debe ingresar el nombre del archivo. Si el archivo existe, imprima "||" a la izquierda y, si no existe, imprima el contenido a la derecha de "||".


Variables predeterminadas (Experimento 4):
$ 0 ~ $ n: indica los parámetros del script de shell, incluido el comando del script de shell (que es $ 0).
$ #: # Indica la etiqueta del último parámetro.
$ @: Significa $ 1, $ 2, $ 3 ...

3.2. El guión condicionará el juicio, la función y el bucle

Juicio condicional (Experimento 1):

declaración de caso (Experimento 2):

llamada a la función (Experimento 3):


parámetro de transferencia de función (Experimento 4):


bucle do done (Experimento 5): bucle cuando se establece la condición, si la entrada no está en el experimento "Cerrar" sigue en bucle.


hasta completar el bucle (Experimento 6): bucle cuando no se establece la condición y salir del bucle cuando se establece la condición.

para bucle (Experimento 7):


para datos de procesamiento de bucle (Experimento 8):

Guía de desarrollo puntual atómica incrustada de linux