Fichier d'en-tête <intrins.h>, explication du rôle de #pragma

Dans le langage C, le fichier d'en-tête (fichier d'en-tête) est utilisé pour stocker les déclarations et les définitions des fonctions, des variables et des types. Ils sont généralement inclus dans les fichiers de code source pour être référencés et utilisés par le compilateur au moment de la compilation. Le fichier d'en-tête a les fonctions suivantes :

1. Déclaration des fonctions et des variables : Le fichier d'en-tête contient des déclarations de fonctions et de variables, indiquant au compilateur leur existence et leur type. Cela permet au compilateur de traiter et de générer correctement le code correspondant lorsque des fonctions et des variables sont utilisées dans les fichiers de code source.

2. Déclarations de type et de structure : les fichiers d'en-tête peuvent contenir des déclarations de type et de structure personnalisées. De cette manière, lors de l'utilisation de ces types et structures personnalisés dans les fichiers de code source, les déclarations répétées peuvent être évitées et la lisibilité et la maintenabilité du code peuvent être améliorées.

3. Définition de macro : le fichier d'en-tête peut contenir des déclarations de diverses définitions et constantes de macro de prétraitement. Ces définitions de macro peuvent être utilisées pour définir des constantes, une compilation conditionnelle et des commutateurs de fonction. En incluant le même fichier d'en-tête dans différents fichiers de code source, ces définitions de macros peuvent être partagées, améliorant ainsi la cohérence du code.

4. Définitions des fonctions et des variables : les fichiers d'en-tête peuvent contenir des définitions de fonctions et de variables. Lorsque vous devez utiliser la même fonction et la même variable dans plusieurs fichiers de code source, vous pouvez placer leurs définitions dans le fichier d'en-tête, puis inclure le fichier d'en-tête dans le fichier de code source qui doit être utilisé.

5. Modularité et organisation du code : le code peut être modularisé et organisé en plaçant des fonctions, des variables et des types associés dans un seul fichier d'en-tête. De cette façon, lorsque vous devez utiliser les fonctions d'un certain module, il vous suffit d'inclure le fichier d'en-tête du module sans connaître les détails d'implémentation spécifiques à l'intérieur.

Il convient de noter que le fichier d'en-tête lui-même ne génère pas directement de code exécutable, il ne contient que des déclarations et des définitions que le compilateur doit utiliser au moment de la compilation. Les fichiers d'en-tête sont couramment utilisés .hcomme extensions de fichier et #includesont inclus et référencés dans les fichiers de code source via des directives de prétraitement.
Les fichiers sources sont les suivants :

/*--------------------------------------------------------------------------
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.hfichier, fournissant des déclarations et des définitions pour certaines fonctions intégrées.

Le début du fichier contient des informations sur le copyright et quelques notes.

Vient ensuite l'instruction de prétraitement pour la compilation conditionnelle, qui est utilisée pour définir des fonctions et définir des attributs en fonction du type de compilateur.

Ensuite, une série de prototypes de fonctions sont définis, y compris _nop_, _testbit_, , _cror_, _iror_, _lror_, _crol_, _irol_, _lrol_, et , , , fonctions _chkfloat_dans des conditions spécifiques .abs_illop__push__pop_

Enfin, utilisez #pragmales directives pour enregistrer et restaurer certains paramètres du compilateur.

Le rôle de #pragma

#pragmaest une directive de prétraitement qui envoie des instructions spécifiques au compilateur pour contrôler son comportement et ses paramètres. Il est généralement utilisé pour fournir des instructions ou des instructions supplémentaires au compilateur pour les optimisations spécifiques au compilateur, les contrôles d'avertissement, les paramètres d'alignement, etc.

#pragmaLe rôle comporte principalement les aspects suivants :

1. Instructions d'optimisation du compilateur : #pragmapeuvent être utilisées pour envoyer des instructions d'optimisation des performances au compilateur. Par exemple, #pragma inlinel'optimisation de l'intégration des fonctions peut être activée, #pragma optimizedes niveaux d'optimisation au niveau des fonctions peuvent être définis, etc. En utilisant ces directives, vous indiquez au compilateur comment optimiser votre code pour améliorer les performances de votre programme.

2. Contrôle d'avertissement du compilateur : #pragmapeut être utilisé pour contrôler les messages d'avertissement générés par le compilateur. Par exemple, #pragma warningil peut être utilisé pour contrôler l'affichage et le masquage d'avertissements spécifiques ou pour définir le niveau des avertissements. En utilisant ces directives, vous pouvez contrôler de manière flexible la sortie d'avertissement du compilateur.

3. Paramètre d'alignement : #pragmaIl peut être utilisé pour définir l'alignement des structures, des variables ou des objets. Par exemple, #pragma packl'alignement d'une structure peut être défini ou #pragma pack(push, n)et #pragma pack(pop)peut être défini et restauré dans un bloc de code spécifié. En utilisant ces directives, l'alignement de la mémoire peut être contrôlé pour améliorer l'efficacité de l'accès aux données.

4. Autres instructions de fonction spécifiques : #pragmaelles peuvent également être utilisées pour implémenter certaines instructions de fonction spécifiques au compilateur. Par exemple, #pragma onceil peut être utilisé pour demander au compilateur de n'inclure qu'une seule fois un fichier d'en-tête particulier, #pragma messagede générer un message personnalisé au moment de la compilation, etc.

#pragma SAVEIl s'agit d'une instruction pour un compilateur spécifique, qui est utilisée pour enregistrer les paramètres actuels du compilateur et modifier certains paramètres spécifiques. Il est généralement #pragma RESTOREassocié à .

#pragma SAVELes fonctions incluent :

1. Enregistrer et modifier les paramètres de registre : #pragma SAVEVous pouvez enregistrer les paramètres de registre actuels et modifier la façon dont les registres sont utilisés. Par exemple, dans certains systèmes embarqués, #pragma SAVEles registres peuvent être sauvegardés sur la pile par paramétrage, afin que la valeur du registre ne soit pas détruite lors de l'appel de la fonction.

2. Enregistrer et modifier les paramètres de la bibliothèque de fonctions : #pragma SAVEvous pouvez également enregistrer les paramètres actuels de la bibliothèque de fonctions et modifier les bibliothèques de fonctions associées. Par exemple, dans certains systèmes embarqués, vous pouvez #pragma SAVEdéfinir la méthode de dénomination de la bibliothèque de fonctions ou activer/désactiver une bibliothèque de fonctions spécifique.

3. Enregistrement et modification d'autres paramètres du compilateur : #pragma SAVEpeut également impliquer l'enregistrement et la modification d'autres paramètres spécifiques au compilateur. La portée et l'effet spécifiques de la modification dépendent des différents compilateurs et plates-formes.

Il convient de noter qu'il #pragma SAVEs'agit d'une instruction d'un compilateur spécifique et que ses fonctions et méthodes d'utilisation spécifiques peuvent être différentes. Lors de son utilisation, la documentation pertinente du compilateur doit être consultée pour des informations plus détaillées. En outre, il convient d'être prudent lors de l'utilisation de cette directive dans des projets multiplateformes ou multicompilateurs en raison des différences entre les différents compilateurs.