Suivre la trace des calculatrices: SpeedCrunch

L'étude du code de la calculatrice continue! Dans cette revue, le projet SpeedCrunch sera examiné - le deuxième plus populaire parmi les calculatrices gratuites.

Présentation

SpeedCrunch est une calculatrice scientifique de précision pilotée par clavier avec une interface utilisateur rapide. Il s'agit d'un logiciel gratuit et open source disponible sur Windows, Linux et macOS.

Le code source est hébergé sur BitBucket . Je n'aimais pas vraiment la documentation d'assemblage, qui, à mon avis, devrait être écrite plus en détail. Les exigences spécifient «Qt 5.2 ou version ultérieure», bien que plusieurs packages spécifiques aient été nécessaires, ce qui n'était pas facile à apprendre du journal CMake. Soit dit en passant, il est désormais recommandé d'appliquer un Dockerfile à un projet pour configurer rapidement l'environnement de développement souhaité.

Pour comparaison avec d'autres calculatrices, j'apporte la sortie de l'utilitaire Cloc:

Avis de bugs dans d'autres projets:

• Compter les bogues dans la calculatrice Windows
• Suivre la trace des calculatrices: Qalculate!

PVS-Studio a été utilisé comme outil d'analyse statique. Il s'agit d'un ensemble de solutions pour le contrôle de la qualité du code, la recherche d'erreurs et les vulnérabilités potentielles. Les langages pris en charge incluent: C, C ++, C # et Java. L'analyseur peut être lancé sur Windows, Linux et macOS.

Logique étrange dans une boucle

V560 Une partie de l'expression conditionnelle est toujours vraie:! RuleFound. evaluator.cpp 1410

void Evaluator::compile(const Tokens& tokens) { .... while (!syntaxStack.hasError()) { bool ruleFound = false; // <= // Rule for function last argument: id (arg) -> arg. if (!ruleFound && syntaxStack.itemCount() >= 4) { // <= Token par2 = syntaxStack.top(); Token arg = syntaxStack.top(1); Token par1 = syntaxStack.top(2); Token id = syntaxStack.top(3); if (par2.asOperator() == Token::AssociationEnd && arg.isOperand() && par1.asOperator() == Token::AssociationStart && id.isIdentifier()) { ruleFound = true; // <= syntaxStack.reduce(4, MAX_PRECEDENCE); m_codes.append(Opcode(Opcode::Function, argCount)); #ifdef EVALUATOR_DEBUG dbg << "\tRule for function last argument " << argCount << " \n"; #endif argCount = argStack.empty() ? 0 : argStack.pop(); } } .... } .... } 

Notez la variable ruleFound . À chaque itération, elle est définie sur false. Mais si vous regardez le corps de l'ensemble du cycle, dans certaines conditions, cette variable est définie sur true, mais elle ne sera pas prise en compte lors de la nouvelle itération du cycle. Très probablement, la variable ruleFound devait être déclarée avant la boucle.

Comparaisons suspectes

V560 Une partie de l'expression conditionnelle est toujours vraie: m_scrollDirection! = 0. resultdisplay.cpp 242

 void ResultDisplay::fullContentScrollEvent() { QScrollBar* bar = verticalScrollBar(); int value = bar->value(); bool shouldStop = (m_scrollDirection == -1 && value <= 0) || (m_scrollDirection == 1 && value >= bar->maximum()); if (shouldStop && m_scrollDirection != 0) { // <= stopActiveScrollingAnimation(); return; } scrollLines(m_scrollDirection * 10); } 

Si la variable shouldStop est vraie , alors la variable m_scrollDirection aura l'une des deux valeurs: -1 ou 1. Par conséquent, dans l'instruction conditionnelle suivante, la valeur de la variable m_scrollDirection ne sera certainement pas nulle, ce que l'analyseur avertit.

V668 Il est inutile de tester le pointeur 'item' sur null, car la mémoire a été allouée à l'aide de l'opérateur 'new'. L'exception sera générée en cas d'erreur d'allocation de mémoire. editor.cpp 998

 void EditorCompletion::showCompletion(const QStringList& choices) { .... for (int i = 0; i < choices.count(); ++i) { QStringList pair = choices.at(i).split(':'); QTreeWidgetItem* item = new QTreeWidgetItem(m_popup, pair); if (item && m_editor->layoutDirection() == Qt::RightToLeft) item->setTextAlignment(0, Qt::AlignRight); .... } .... } 

La mémoire d'un objet de type QTreeWidgetItem est allouée à l'aide du nouvel opérateur. Cela signifie que si l'allocation dynamique de mémoire n'est pas possible, une exception std :: bad_alloc () sera levée. Par conséquent, la vérification du pointeur de l' élément est superflue et peut être supprimée.

Déréférence NULL potentielle

V595 Le pointeur «ioparams» a été utilisé avant d'être vérifié par rapport à nullptr. Vérifiez les lignes: 969, 983. floatio.c 969

 int cattokens(....) { .... if (printexp) { if (expbase < 2) expbase = ioparams->expbase; // <= .... } dot = '.'; expbegin = "("; expend = ")"; if (ioparams != NULL) // <= { dot = ioparams->dot; expbegin = ioparams->expbegin; expend = ioparams->expend; } .... } 

Le pointeur ioparams est déréférencé avant d'être vérifié pour sa validité. Très probablement, une erreur potentielle s'est glissée dans le code. Le déréférencement étant soumis à plusieurs conditions, le problème peut se manifester rarement, mais avec précision.

Division par zéro

V609 Divisez par zéro. Plage du dénominateur [0..4]. floatconvert.c 266

 static int lgbase( signed char base) { switch(base) { case 2: return 1; case 8: return 3; case 16: return 4; } return 0; // <= } static void _setlongintdesc( p_ext_seq_desc n, t_longint* l, signed char base) { int lg; n->seq.base = base; lg = lgbase(base); // <= n->seq.digits = (_bitlength(l) + lg - 1) / lg; // <= n->seq.leadingSignDigits = 0; n->seq.trailing0 = _lastnonzerobit(l) / lg; // <= n->seq.param = l; n->getdigit = _getlongintdigit; } 

La fonction lgbase permet de renvoyer une valeur nulle, par laquelle la division est ensuite effectuée. Potentiellement, tout autre élément que les valeurs 2, 8 et 16 peut être transmis à la fonction.

Comportement indéfini

V610 Comportement indéfini . Vérifiez l'opérateur de décalage «<<». L'opérande gauche '(~ 0)' est négatif. floatlogic.c 64

 static char _signextend( t_longint* longint) { unsigned mask; signed char sign; sign = _signof(longint); mask = (~0) << SIGNBIT; // <= if (sign < 0) longint->value[MAXIDX] |= mask; else longint->value[MAXIDX] &= ~mask; return sign; } 

Le résultat de l'inversion de zéro est placé dans le type de signe int , donc le résultat sera un nombre négatif, pour lequel un décalage est ensuite effectué. Décaler un nombre négatif vers la gauche est un comportement indéfini.

La liste complète des endroits dangereux:

• V610 Comportement indéfini. Vérifiez l'opérateur de décalage «<<». L'opérande gauche '(- 1)' est négatif. floatnum.c 289
• V610 Comportement indéfini. Vérifiez l'opérateur de décalage «<<». L'opérande gauche '(- 1)' est négatif. floatnum.c 325
• V610 Comportement indéfini. Vérifiez l'opérateur de décalage «<<». L'opérande gauche '(- 1)' est négatif. floatnum.c 344
• V610 Comportement indéfini. Vérifiez l'opérateur de décalage «<<». L'opérande gauche '(- 1)' est négatif. floatnum.c 351

Balises HTML non fermées

V735 Peut-être un HTML incorrect. La balise de fermeture "</body>" a été rencontrée, tandis que la balise "</div>" était attendue. book.cpp 127

 static QString makeAlgebraLogBaseConversionPage() { return BEGIN INDEX_LINK TITLE(Book::tr("Logarithmic Base Conversion")) FORMULA(y = log(x) / log(a), log<sub>a</sub>x = log(x) / log(a)) END; } 

Comme cela arrive souvent avec le code C / C ++, rien n'est clair à partir de la source, alors passons au code prétraité pour ce fragment:

L'analyseur a détecté une étiquette div non fermée. Il y a beaucoup de fragments de code html dans ce fichier et maintenant il devrait être vérifié en plus par les développeurs.

Voici quelques endroits plus suspects qui ont été trouvés en utilisant PVS-Studio:

• V735 Peut-être un HTML incorrect. La balise de fermeture "</td>" a été rencontrée, tandis que la balise "</sub>" était attendue. book.cpp 344
• V735 Peut-être un HTML incorrect. La balise de fermeture "</td>" a été rencontrée, tandis que la balise "</sub>" était attendue. book.cpp 347

Opérateur d'affectation

V794 L'opérateur d'affectation doit être protégé contre le cas de 'this == & other'. quantité.cpp 373

 Quantity& Quantity::operator=(const Quantity& other) { m_numericValue = other.m_numericValue; m_dimension = other.m_dimension; m_format = other.m_format; stripUnits(); if(other.hasUnit()) { m_unit = new CNumber(*other.m_unit); m_unitName = other.m_unitName; } cleanDimension(); return *this; } 

Il est recommandé de considérer la situation lorsque l'objet est assigné à lui-même en comparant les pointeurs.

En d'autres termes, les deux lignes de code suivantes doivent être ajoutées au début du corps de la fonction:

 if (this == &other) return *this; 

Rappel

V601 La valeur 'false' est implicitement convertie en type entier. cmath.cpp 318

 /** * Returns -1, 0, 1 if n1 is less than, equal to, or more than n2. * Only valid for real numbers, since complex ones are not an ordered field. */ int CNumber::compare(const CNumber& other) const { if (isReal() && other.isReal()) return real.compare(other.real); else return false; // FIXME: Return something better. } 

Parfois, dans les commentaires de nos articles, ils suggèrent que certains avertissements sont émis sur un code incomplet. Oui, cela arrive, mais quand c'est vraiment le cas, c'est écrit directement à ce sujet.

Conclusion

Examens déjà disponibles de trois calculatrices: Windows Calculator, Qalculate! et SpeedCrunch. Nous sommes prêts à continuer de rechercher le code des calculatrices populaires. Vous pouvez proposer des projets pour vérification, car les évaluations du logiciel ne reflètent pas toujours l'image réelle.

Vérifiez votre «calculatrice» en téléchargeant PVS-Studio et en essayant votre projet :-)

Si vous souhaitez partager cet article avec un public anglophone, veuillez utiliser le lien vers la traduction: Svyatoslav Razmyslov. Suivre les traces des calculatrices: SpeedCrunch