Archivo de encabezado <intrins.h>, explicación del rol de #pragma

En el lenguaje C, el archivo de encabezado (Header file) se usa para almacenar declaraciones y definiciones de funciones, variables y tipos. Por lo general, se incluyen en los archivos de código fuente para que el compilador haga referencia a ellos y los utilice en el momento de la compilación. El archivo de encabezado tiene las siguientes funciones:

1. Declaración de funciones y variables: El archivo de cabecera contiene declaraciones de funciones y variables, indicando al compilador su existencia y tipo. Esto permite que el compilador procese y genere correctamente el código correspondiente cuando se utilizan funciones y variables en los archivos de código fuente.

2. Declaraciones de tipo y estructura: los archivos de encabezado pueden contener declaraciones personalizadas de tipo y estructura. De esta forma, cuando se utilizan estos tipos y estructuras personalizados en los archivos de código fuente, se pueden evitar las declaraciones repetidas y se puede mejorar la legibilidad y el mantenimiento del código.

3. Definición de macro: el archivo de encabezado puede contener declaraciones de varias definiciones y constantes de macro de preprocesamiento. Estas definiciones de macros se pueden usar para definir constantes, compilación condicional e interruptores de función. Al incluir el mismo archivo de encabezado en diferentes archivos de código fuente, estas definiciones de macro se pueden compartir, lo que mejora la consistencia del código.

4. Definiciones de funciones y variables: los archivos de encabezado pueden contener definiciones de funciones y variables. Cuando necesite usar la misma función y variable en varios archivos de código fuente, puede poner sus definiciones en el archivo de encabezado y luego incluir el archivo de encabezado en los archivos de código fuente que deben usarse.

5. Modularidad y organización del código: el código se puede modularizar y organizar colocando funciones, variables y tipos relacionados en un solo archivo de encabezado. De esta forma, cuando necesite usar las funciones de un determinado módulo, solo necesita incluir el archivo de encabezado del módulo sin conocer los detalles de implementación específicos dentro de él.

Cabe señalar que el archivo de encabezado en sí mismo no genera código ejecutable directamente, solo contiene declaraciones y definiciones para que el compilador las use en el momento de la compilación. Los archivos de encabezado se usan comúnmente .hcomo extensiones de archivo y #includese incluyen y se hace referencia en los archivos de código fuente a través de directivas de preprocesamiento.
Los archivos fuente son los siguientes:

/*--------------------------------------------------------------------------
INTRINS.H

Intrinsic functions for C51.
Copyright (c) 1988-2010 Keil Elektronik GmbH and ARM Germany GmbH
All rights reserved.
--------------------------------------------------------------------------*/

#ifndef __INTRINS_H__
#define __INTRINS_H__

#pragma SAVE

#if defined (__CX2__)
#pragma FUNCTIONS(STATIC)
/* intrinsic functions are reentrant, but need static attribute */
#endif

extern void          _nop_     (void);
extern bit           _testbit_ (bit);
extern unsigned char _cror_    (unsigned char, unsigned char);
extern unsigned int  _iror_    (unsigned int,  unsigned char);
extern unsigned long _lror_    (unsigned long, unsigned char);
extern unsigned char _crol_    (unsigned char, unsigned char);
extern unsigned int  _irol_    (unsigned int,  unsigned char);
extern unsigned long _lrol_    (unsigned long, unsigned char);
extern unsigned char _chkfloat_(float);
#if defined (__CX2__)
extern int           abs       (int);
extern void          _illop_   (void);
#endif
#if !defined (__CX2__)
extern void          _push_    (unsigned char _sfr);
extern void          _pop_     (unsigned char _sfr);
#endif

#pragma RESTORE

#endif

intrins.harchivo, proporcionando declaraciones y definiciones para algunas funciones integradas.

El comienzo del archivo contiene información de derechos de autor y algunas notas.

Lo siguiente es la instrucción de preprocesamiento para la compilación condicional, que se utiliza para definir funciones y establecer atributos según el tipo de compilador.

Luego se definen una serie de prototipos de funciones, incluyendo _nop_, _testbit_, , _cror_, _iror_, _lror_, _crol_, _irol_, _lrol_, y , , , funciones _chkfloat_bajo condiciones específicas .abs_illop__push__pop_

Finalmente, use #pragmalas directivas para guardar y restaurar algunas configuraciones del compilador.

El papel del #pragma

#pragmaes una directiva de preprocesamiento que envía instrucciones específicas al compilador para controlar su comportamiento y configuración. Por lo general, se usa para proporcionar algunas instrucciones adicionales o instrucciones al compilador para optimizaciones específicas del compilador, controles de advertencia, configuraciones de alineación, etc.

#pragmaEl rol tiene principalmente los siguientes aspectos:

1. Instrucciones de optimización del compilador: #pragmase pueden usar para enviar instrucciones de optimización del rendimiento al compilador. Por ejemplo, #pragma inlinese puede habilitar la optimización de función en línea, #pragma optimizese pueden establecer niveles de optimización de nivel de función, etc. Al usar estas directivas, le indica al compilador cómo optimizar su código para mejorar el rendimiento de su programa.

2. Control de advertencia del compilador: #pragmase puede usar para controlar los mensajes de advertencia generados por el compilador. Por ejemplo, #pragma warningse puede utilizar para controlar la visualización y ocultación de advertencias específicas o para establecer el nivel de las advertencias. Mediante el uso de estas directivas, puede controlar de manera flexible la salida de advertencia del compilador.

3. Configuración de alineación: #pragmase puede utilizar para configurar la alineación de estructuras, variables u objetos. Por ejemplo, #pragma packse puede establecer la alineación de una estructura o #pragma pack(push, n)se #pragma pack(pop)puede establecer y restaurar dentro de un bloque de código específico. Mediante el uso de estas directivas, se puede controlar la alineación de la memoria para mejorar la eficiencia del acceso a los datos.

4. Otras instrucciones de funciones específicas: #pragmatambién se puede usar para implementar algunas instrucciones de funciones específicas del compilador. Por ejemplo, #pragma oncese puede usar para indicar al compilador que solo incluya un archivo de encabezado en particular una vez, #pragma messagepara generar un mensaje personalizado en el momento de la compilación, etc.

#pragma SAVEEs una instrucción para un compilador específico, que se utiliza para guardar la configuración actual del compilador y modificar algunas configuraciones específicas. Suele ir #pragma RESTOREemparejado con .

#pragma SAVELas funciones incluyen:

1. Guardar y modificar la configuración del registro: #pragma SAVEpuede guardar la configuración actual del registro y modificar la forma en que se utilizan los registros. Por ejemplo, en algunos sistemas integrados, #pragma SAVElos registros se pueden guardar en la pila configurando, de modo que el valor del registro no se destruya cuando se llama a la función.

2. Guarde y modifique la configuración de la biblioteca de funciones: #pragma SAVEtambién puede guardar la configuración actual de la biblioteca de funciones y modificar las bibliotecas de funciones relacionadas. Por ejemplo, en algunos sistemas integrados, puede #pragma SAVEestablecer el método de denominación de la biblioteca de funciones o habilitar/deshabilitar una biblioteca de funciones específica.

3. Guardar y modificar otras configuraciones del compilador: #pragma SAVEtambién puede implicar guardar y modificar otras configuraciones específicas del compilador. El alcance y el efecto de la modificación específica dependen de los diferentes compiladores y plataformas.

Cabe señalar que #pragma SAVEes una instrucción de un compilador específico, y sus funciones específicas y métodos de uso pueden ser diferentes. Cuando esté en uso, se debe consultar la documentación relevante del compilador para obtener información más detallada. Además, se debe tener cuidado al usar esta directiva en proyectos multiplataforma o de compiladores cruzados debido a las diferencias entre los diferentes compiladores.