Quel est le meilleur outil de ligne de commande pour nettoyer le code ?

Question

Quand j'écris C - code j'utilise uniquement un éditeur et gcc. Je me demandais si quelqu'un pourrait suggérer un bon outil simple qui trouvera des variables inutilisées, des déclarations de fonction et peut-être faire quelques optimisations.

Quelqu'un connaît-il un bon outil?

Answer 1

Comme Dan Fego souligné, GCC peut attraper les variables non utilisés et des fonctions statiques. Il ne retrouve pas habituellement inutilisés extern fonctions qu'il fonctionne normalement, un seul fichier à la fois.

GCC (v4.3.2) a des centaines, si pas des milliers d'options. Une situation qui pourrait aider est '--combine"pour combiner les fichiers source (tant que vous n'êtes pas dans l'habitude de mettre la même fonction ou des noms de variables à l'intérieur de différents fichiers source).

L'option '--help' vous en dit plus: les options '--help=optimizers"et"--help=warnings"chacun de vous donner quelques centaines de lignes de sortie. Les avertissements sont:

-Wunused                    This switch lacks documentation
-Wunused-function           Warn when a function is unused
-Wunused-label              This switch lacks documentation
-Wunused-macros             Warn about macros defined in the main file that
                            are not used
-Wunused-parameter          Warn when a function parameter is unused
-Wunused-value              Warn when an expression value is unused
-Wunused-variable           Warn when a variable is unused

---

Ajouté: c'est un script qui s'appelle glint que j'utilise pour désinfecter mon code. Il est assez vieux pour ne pas utiliser le '#!/bin/sh"de notation pour la première ligne et il dit '$*"au lieu de""$@"', qui doit être fixe, mais ni les besoins d'être fixé rapidement. Notez que même si GCC 4.x ne supporte plus l' '-fwriteable-strings' option, il prend toujours en charge de la '-Wwrite-strings' option et qui a de la valeur.

Ce script montre que vous pouvez obtenir beaucoup de kilométrage des outils existants avec seulement une petite quantité de travail. Vous pouvez configurer juste au sujet de toutes les options qu'il utilise mais principalement par le biais de l'environnement plutôt que sur la ligne de commande. Bien sûr, vous pouvez ajouter des options d'alerte à la ligne de commande; ce que vous ne pouvez pas faire est de retirer prédéterminé options sauf via l'environnement. Mais c'est OK, ils sont choisis par défaut pour de bonnes raisons. Ces jours-ci, je serais probablement set 'GLINT_ANSI=-std=c99' ou de corriger le script; je n'ai pas pu l'utiliser beaucoup de retard depuis que je code assez étroitement à la norme que l' glint applique. (Notez que le '-o /dev/null"signifie que vous ne pouvez faire qu'un seul fichier à la fois; hack pour corriger!)

:   "@(#)$Id: glint.sh,v 1.5 2002/08/09 21:40:52 jleffler Exp jleffler $"
#
#   Use GCC as excruciatingly pedantic lint
#   Not a complete replacement for lint -- it doesn't do inter-file checking.
#   Now configurable via the environment.
#   Use GLINT_EXTRA_FLAGS to set extra flags via the environment.
#   NB: much Solaris code won't work with -undef enabled.

: ${GLINT_GCC:='gcc'}

: ${GLINT_ANSI='-ansi'}
: ${GLINT_FNO_COMMON='-fno-common'}
: ${GLINT_FSHORT_ENUMS='-fshort-enums'}
: ${GLINT_PEDANTIC='-pedantic'}
: ${GLINT_UNDEF='-undef'}
: ${GLINT_W='-W'}
: ${GLINT_WAGGREGATE_RETURN='-Waggregate-return'}
: ${GLINT_WALL='-Wall'}
: ${GLINT_WCAST_ALIGN='-Wcast-align'}
: ${GLINT_WCAST_QUAL='-Wcast-qual'}
: ${GLINT_WCONVERSION='-Wconversion'}
: ${GLINT_WMISSING_DECLARATIONS='-Wmissing-declarations'}
: ${GLINT_WREDUNDANT_DECLS='-Wredundant-decls'}
: ${GLINT_WMISSING_PROTOTYPES='-Wmissing-prototypes'}
: ${GLINT_WNESTED_EXTERNS='-Wnested-externs'}
: ${GLINT_WPOINTER_ARITH='-Wpointer-arith'}
: ${GLINT_WSHADOW='-Wshadow'}
: ${GLINT_WSTRICT_PROTOTYPES='-Wstrict-prototypes'}
: # ${GLINT_WTRADITIONAL='-Wtraditional'}
: ${GLINT_WWRITE_STRINGS='-Wwrite-strings'}

exec ${GLINT_GCC} \
    ${GLINT_ANSI} \
    ${GLINT_FNO_COMMON} \
    ${GLINT_FSHORT_ENUMS} \
    ${GLINT_PEDANTIC} \
    ${GLINT_UNDEF} \
    ${GLINT_WAGGREGATE_RETURN} \
    ${GLINT_WALL} \
    ${GLINT_WCAST_ALIGN} \
    ${GLINT_WCAST_QUAL} \
    ${GLINT_WCONVERSION} \
    ${GLINT_WMISSING_DECLARATIONS} \
    ${GLINT_WREDUNDANT_DECLS} \
    ${GLINT_WMISSING_PROTOTYPES} \
    ${GLINT_WNESTED_EXTERNS} \
    ${GLINT_WPOINTER_ARITH} \
    ${GLINT_WSHADOW} \
    ${GLINT_WSTRICT_PROTOTYPES} \
    ${GLINT_WTRADITIONAL} \
    ${GLINT_WWRITE_STRINGS} \
    ${GLINT_W} \
    ${GLINT_EXTRA_FLAGS} \
    -o /dev/null -O4 -g -c $*

Answer 2

La tinte est l'outil classique pour vérifier le style sur les programmes C. Il y a une incarnation plus moderne de celui-ci appelé Splint. Cette entrée Wikipédia a une liste d'outils statiques d'analyse de code, certains gratuits, certains commerciaux.

Answer 3

Si vous exécutez gcc avec -Wall, il va attraper certaines des choses que vous mentionnez, telles que les variables inutilisées (et peut-être des fonctions inutilisées). En termes d'optimisations, je n'ai pas, mais en général le compilateur est assez intelligent pour faire les types d'optimisations qui comptent, donc je ne m'inquiéterais pas trop. N'utilisez pas d'algorithmes horribles. ;-)

Answer 4

attelle (http://www.splint.org/) est tout à fait excellent; Je l'ai utilisé un code mégaline pour chercher ce genre de chose,

(Mise à jour: tout le monde veut être un directeur artistique.)