cproto - En ligne dans le Cloud

PROGRAMME:

Nom

cproto - générer des prototypes de fonctions C et convertir des définitions de fonctions

SYNOPSIS

cproto [ option ... ] [ filet ...]

DESCRIPTION

Cproto génère des prototypes de fonction pour les fonctions définies dans les fichiers source C spécifiés
à la sortie standard. Les définitions de fonction peuvent être dans l'ancien style ou dans le style ANSI C.
le cas échéant, cproto génère également des déclarations pour les variables définies dans les fichiers. Sinon
filet argument est donné, cproto lit son entrée à partir de l'entrée standard.

En donnant une option de ligne de commande, cproto convertira également les définitions de fonction dans le
fichiers spécifiés de l'ancien style au style ANSI C. Les fichiers sources originaux ainsi que
avec les fichiers spécifiés par
#include "fichier"
les directives apparaissant dans le code source seront écrasées par le code converti. Si
aucun nom de fichier n'est donné sur la ligne de commande, alors le programme lit le code source à partir de
l'entrée standard et sort la source convertie vers la sortie standard.

Si des commentaires apparaissent dans les déclarations de paramètres d'une définition de fonction, comme dans
l'exemple,
principal (argc, argv)
int argc; /* nombre d'arguments */
caractère *argv[] ; /* arguments */
{
}
alors la définition de fonction convertie aura la forme
int
principale (
int argc, /* nombre d'arguments */
char *argv[] /* arguments */
)
{
}
Sinon, la définition de fonction convertie ressemblera à
int
principal (int argc, char *argv[])
{
}

Cproto peut éventuellement convertir les définitions de fonction du style ANSI vers l'ancien style.
Dans ce mode, le programme convertit également les déclarateurs de fonction et les prototypes qui apparaissent
en dehors des corps de fonction. Il ne s'agit pas d'une conversion complète ANSI C vers l'ancien C. Le programme
ne change rien dans les corps de fonction.

Cproto peut éventuellement générer une source au format lint-library. Ceci est utile dans
environnements où le peluche utilitaire est utilisé pour compléter la vérification du prototype de votre
.

OPTIONS

-e Sortir le mot-clé externe devant chaque prototype généré ou déclaration qui
a une portée mondiale.

-f n Définir le style des prototypes de fonction générés où n est un nombre de 0 à 3.
Par exemple, considérons la définition de la fonction
principal (argc, argv)
int argc ;
caractère *argv[] ;
{
}
Si la valeur est 0, aucun prototype n'est généré. Lorsqu'il est défini sur 1, la sortie est :
int main(/*int argc, char *argv[]*/);
Pour une valeur de 2, la sortie a la forme :
int main(int /*argc*/, char */*argv*/[]);
La valeur par défaut est 3. Elle produit le prototype de fonction complet :
int main(int argc, char *argv[]);

-l Générer du texte pour une bibliothèque Lint (remplace le "-f"). La sortie comprend
le commentaire
/* BIBLIOTHÈQUE LINT */
Les commentaires spéciaux LINT_EXTERN et LINT_PREPRO (à la "VARARGS") s'activent respectivement
l'option "-x" et copiez le texte du commentaire dans la sortie (pour le prétraitement dans peluche).
Utiliser le commentaire
/* LINT_EXTERN2 */
pour inclure les externs définis dans le premier niveau des fichiers d'inclusion. Utiliser le commentaire
/* LINT_SHADOWED */
provoquer cproto mettre les directives "#undef" avant chaque déclaration de bibliothèque lint
(c'est-à-dire pour éviter les conflits avec les macros qui doivent avoir le même nom que
les fonctions, provoquant ainsi des erreurs de syntaxe).

Notez que ces commentaires spéciaux ne sont pas pris en charge sous VAX/VMS, car il n'y a pas
équivalent pour l'option "-C" de cpp avec VAX-C.

-c Les commentaires de paramètres dans les prototypes générés par les options -f1 et -f2 sont
omis par défaut. Utilisez cette option pour activer la sortie de ces commentaires.

-m Mettez une macro autour de la liste des paramètres de chaque prototype généré. Par exemple:
int main P_((int argc, char *argv[]));

-M prénom
Définissez le nom de la macro utilisée pour entourer les listes de paramètres de prototype lorsque l'option -m
est sélectionné. La valeur par défaut est "P_".

-d Omettez la définition de la macro prototype utilisée par l'option -m.

-o filet
Spécifiez le nom du fichier de sortie (par défaut : sortie standard).

-O filet
Spécifiez le nom du fichier d'erreurs (par défaut : erreur standard).

-p Désactivez la promotion des paramètres formels dans les anciennes définitions de fonctions. Par
par défaut, paramètres de type carboniser or court dans l'ancien style, les définitions de fonctions sont
promu au type int dans le prototype de fonction ou la fonction ANSI C convertie
définition. Paramètres de type flotter être promu à double également.

-q N'affiche aucun message d'erreur lorsque le programme ne peut pas lire le fichier spécifié dans
an #comprendre Directive.

-s Par défaut, cproto génère uniquement des déclarations pour les fonctions et les variables ayant
portée mondiale. Cette option affichera statique déclarations aussi.

-S Afficher uniquement les déclarations statiques.

-i Par défaut, cproto génère uniquement des déclarations pour les fonctions et les variables ayant
portée mondiale. Cette option affichera en ligne déclarations aussi.

-T Copiez les définitions de type de chaque fichier. (Les définitions dans les fichiers inclus sont copiées,
contrairement à l'option "-l").

-v Egalement des déclarations de sortie pour les variables définies dans la source.

-x Cette option fait que les procédures et variables déclarées "externes" sont
inclus dans la sortie.

-X niveau
Cette option limite le niveau du fichier d'inclusion à partir duquel les déclarations sont extraites par
examiner la sortie du préprocesseur.

-a Convertissez les définitions de fonction de l'ancien style au style ANSI C.

-t Convertissez les définitions de fonction du style ANSI C au style traditionnel.

-b Réécrire les têtes de définition de fonction pour inclure à la fois l'ancien style et le nouveau style
déclarations séparées par une directive de compilation conditionnelle. Par exemple, le
programme peut générer cette définition de fonction :
#ifdef ANSI_FUNC

int
principal (int argc, char *argv[])
#else

int
principal (argc, argv)
int argc ;
caractère *argv[]
#endif
{
}

-B directive
Définir la directive de compilation conditionnelle à afficher au début de la fonction
définitions générées par l'option -b. La valeur par défaut est
#ifdef ANSI_FUNC

-P modèle
-F modèle
-C modèle
Définir le format de sortie pour les prototypes générés, les définitions de fonction et la fonction
définitions avec des commentaires de paramètres respectivement. Le format est spécifié par un
modèle dans le formulaire
"entier f ( a, b )"
mais vous pouvez remplacer chaque espace de cette chaîne par n'importe quel nombre d'espaces
personnages. Par exemple, l'option
-F"int f(\n\ta,\n\tb\n\t)"
produira
int main(
int argc,
caractère *argv[]
)

-D nom[=valeur]
Cette option est transmise au préprocesseur et est utilisée pour définir des symboles pour
utiliser avec des conditions telles que #ifdef.

-U prénom
Cette option est transmise au préprocesseur et est utilisée pour supprimer tout
définitions de ce symbole.

-I annuaire
Cette option est transmise au préprocesseur et est utilisée pour spécifier un
répertoire pour rechercher les fichiers référencés avec #comprendre.

-E cpp Dirigez les fichiers d'entrée via la commande de préprocesseur C spécifiée lors de la génération
proto. Par défaut, le programme utilise /lib/cpp.

-E 0 N'exécutez pas le préprocesseur C.

-V Imprimer les informations sur la version.

ENVIRONNEMENT

La variable d'environnement CPROTO est analysée pour une liste d'options dans le même format que le
options de ligne de commande. Les options données sur la ligne de commande remplacent toutes les options correspondantes
option environnement.

Utiliser cproto en ligne à l'aide des services onworks.net