C Calculator Debugging Tool

Paste your C calculator code snippet

<label for="wpc-error-message" class="wpc-input-label">Error message (if any)</label>
            <input type="text" id="wpc-error-message" class="wpc-input-field" placeholder="e.g., 'segmentation fault' or 'undefined reference'">
        </div>

<div class="wpc-input-group">
            <label class="wpc-input-label">Compiler</label>
            <select id="wpc-compiler" class="wpc-select-field">
                <option value="gcc">GCC</option>
                <option value="clang">Clang</option>
                <option value="msvc">MSVC</option>
                <option value="other">Other</option>
            </select>
        </div>

<div class="wpc-input-group">
            <label class="wpc-input-label">Compiler flags used</label>
            <input type="text" id="wpc-compiler-flags" class="wpc-input-field" placeholder="e.g., -Wall -Wextra -std=c11">
        </div>

<div class="wpc-input-group">
            <label class="wpc-input-label">Operating System</label>
            <div class="wpc-radio-group">
                <div class="wpc-radio-option">
                    <input type="radio" id="wpc-os-windows" name="wpc-os" value="windows" class="wpc-radio-input" checked>
                    <label for="wpc-os-windows">Windows</label>
                </div>
                <div class="wpc-radio-option">
                    <input type="radio" id="wpc-os-linux" name="wpc-os" value="linux" class="wpc-radio-input">
                    <label for="wpc-os-linux">Linux</label>
                </div>
                <div class="wpc-radio-option">
                    <input type="radio" id="wpc-os-mac" name="wpc-os" value="mac" class="wpc-radio-input">
                    <label for="wpc-os-mac">MacOS</label>
                </div>
            </div>
        </div>

<div class="wpc-input-group">
            <label class="wpc-input-label">Calculator type</label>
            <select id="wpc-calculator-type" class="wpc-select-field">
                <option value="basic">Basic arithmetic</option>
                <option value="scientific">Scientific</option>
                <option value="financial">Financial</option>
                <option value="custom">Custom function</option>
            </select>
        </div>

<button id="wpc-calculate-btn" class="wpc-calculate-btn">Analyze Code</button>
    </div>

<div id="wpc-results" class="wpc-results">
        <h2 class="wpc-result-title">Debugging Analysis Results</h2>
        <div id="wpc-result-content">
            
        </div>
        <div class="wpc-chart-container">
            <canvas id="wpc-chart"></canvas>
        </div>
    </div>
</section>

<article class="wpc-content">
    <h1>Why Is My Calculator in C Not Working? Comprehensive Debugging Guide</h1>

<p>Building a calculator in C is a fundamental programming exercise, but even experienced developers encounter issues that prevent their calculators from functioning correctly. This guide explores the most common reasons why C calculators fail, provides debugging techniques, and offers solutions to get your calculator working properly.</p>

<h2>1. Common Syntax Errors in C Calculators</h2>

<p>Syntax errors are the most frequent cause of non-functioning C programs. These occur when your code violates the language’s grammatical rules.</p>

<h3>1.1 Missing Semicolons</h3>
    <p>C requires semicolons at the end of most statements. A missing semicolon can cause the compiler to misinterpret your code:</p>

<div class="wpc-code-block">
int a = 5
int b = 10  // Missing semicolon on previous line causes this to be interpreted as “10(int b)”
    </div>

<h3>1.2 Mismatched Braces</h3>
    <p>Unbalanced curly braces { } will cause compilation errors. Always ensure every opening brace has a corresponding closing brace:</p>

<div class="wpc-code-block">
int main() {
    printf(“Hello”);
    // Missing closing brace
    </div>

<h3>1.3 Incorrect Header Includes</h3>
    <p>Forgetting to include necessary headers like <code>stdio.h</code> for input/output functions or <code>math.h</code> for mathematical operations:</p>

<div class="wpc-code-block">
#include <stdio.h>
// Missing #include <math.h> for sqrt(), pow(), etc.
    </div>

<h2>2. Logical Errors in Calculator Operations</h2>

<p>Even when your code compiles, logical errors can cause incorrect calculations. These are harder to detect as they don’t generate compiler errors.</p>

<h3>2.1 Integer Division Problems</h3>
    <p>C performs integer division when both operands are integers. This often catches beginners by surprise:</p>

<div class="wpc-code-block">
int result = 5 / 2;  // Result is 2, not 2.5
// Solution: Make at least one operand a float
float correct = 5.0 / 2;  // Result is 2.5
    </div>

<h3>2.2 Operator Precedence Issues</h3>
    <p>C follows specific operator precedence rules that might not match your expectations:</p>

<div class="wpc-code-block">
int result = 5 + 3 * 2;  // Result is 11 (3*2=6, then 5+6=11)
// Use parentheses to control evaluation order
int correct = (5 + 3) * 2;  // Result is 16
    </div>

<h3>2.3 Floating-Point Precision Errors</h3>
    <p>Floating-point arithmetic can introduce small rounding errors due to how numbers are represented in binary:</p>

<div class="wpc-code-block">
if (0.1 + 0.2 == 0.3) {
    // This condition might evaluate to false due to floating-point precision
}
// Better to check if the difference is within a small epsilon
#define EPSILON 0.00001
if (fabs((0.1 + 0.2) – 0.3) < EPSILON) {
    // This is more reliable
}
    </div>

<h2>3. Memory and Pointer Issues</h2>

<p>C’s manual memory management can lead to subtle bugs that crash your calculator or produce incorrect results.</p>

<h3>3.1 Uninitialized Variables</h3>
    <p>Using variables before initialization leads to undefined behavior:</p>

<div class="wpc-code-block">
int result;
// result contains garbage value
printf(“%d”, result);  // Undefined behavior
    </div>

<h3>3.2 Buffer Overflows</h3>
    <p>Writing beyond array bounds corrupts memory and can crash your program:</p>

<div class="wpc-code-block">
int numbers[5];
numbers[5] = 10;  // Writing beyond array bounds
    </div>

<h3>3.3 Dangling Pointers</h3>
    <p>Using pointers to memory that has been freed:</p>

<div class="wpc-code-block">
int *ptr = malloc(sizeof(int));
free(ptr);
// ptr is now dangling
*ptr = 5;  // Undefined behavior
    </div>

<h2>4. Input/Output Problems</h2>

<p>Many calculator issues stem from incorrect input handling or output formatting.</p>

<h3>4.1 Scanf Format String Mismatches</h3>
    <p>Using incorrect format specifiers in <code>scanf</code>:</p>

<div class="wpc-code-block">
int number;
scanf(“%f”, &number);  // Wrong format specifier (should be %d)
    </div>

<h3>4.2 Input Buffer Issues</h3>
    <p>Mixing different input functions can leave newline characters in the buffer:</p>

<div class="wpc-code-block">
int num;
char op;
scanf(“%d”, &num);
// Newline remains in buffer
scanf(“%c”, &op);  // Reads the newline instead of intended character
    </div>

<h3>4.3 Output Formatting Problems</h3>
    <p>Incorrect format specifiers in <code>printf</code> can produce garbage output:</p>

<div class="wpc-code-block">
float result = 3.14159;
printf(“%d”, result);  // Wrong format specifier (should be %f)
    </div>

<h2>5. Compiler and Linker Issues</h2>

<p>Sometimes the problem isn’t in your code but in how it’s being compiled.</p>

<h3>5.1 Missing Math Library</h3>
    <p>For mathematical functions, you need to link the math library:</p>

<div class="wpc-code-block">
// Compile with: gcc mycalc.c -o mycalc -lm
    </div>

<h3>5.2 Compiler Warnings Ignored</h3>
    <p>Always compile with warnings enabled and address them:</p>

<div class="wpc-code-block">
gcc -Wall -Wextra -pedantic mycalc.c -o mycalc
    </div>

<h3>5.3 Architecture-Specific Issues</h3>
    <p>Some code may behave differently on 32-bit vs 64-bit systems or different endianness.</p>

<h2>6. Debugging Techniques for C Calculators</h2>

<p>Systematic debugging is essential for identifying and fixing issues in your C calculator.</p>

<h3>6.1 Using Print Statements</h3>
    <p>Strategically placed print statements can help trace execution:</p>

<div class="wpc-code-block">
printf(“Debug: a=%d, b=%d\n”, a, b);
result = a + b;
printf(“Debug: result=%d\n”, result);
    </div>

<h3>6.2 Using a Debugger</h3>
    <p>Learn to use GDB (GNU Debugger) or your IDE’s debugging tools to:</p>
    <ul>
        <li>Set breakpoints</li>
        <li>Step through code</li>
        <li>Inspect variables</li>
        <li>Examine the call stack</li>
    </ul>

<h3>6.3 Rubber Duck Debugging</h3>
    <p>Explain your code line-by-line to an inanimate object (or a colleague). This often reveals logical flaws.</p>

<h3>6.4 Binary Search Debugging</h3>
    <p>When you have a large program:</p>
    <ol>
        <li>Comment out half the code</li>
        <li>If the problem disappears, the bug is in the commented section</li>
        <li>Repeat with the problematic section</li>
    </ol>

<h2>7. Common Calculator-Specific Issues</h2>

<p>Certain problems are particularly common in calculator implementations.</p>

<h3>7.1 Order of Operations Implementation</h3>
    <p>Many beginner calculators evaluate expressions left-to-right without respecting operator precedence:</p>

<div class="wpc-code-block">
// Incorrect: evaluates 2 + 3 * 4 as (2+3)*4 = 20
// Correct should be 2 + (3*4) = 14
    </div>

<h3>7.2 Division by Zero</h3>
    <p>Always check for division by zero:</p>

<div class="wpc-code-block">
if (denominator == 0) {
    printf(“Error: Division by zero\n”);
    return 1;
}
result = numerator / denominator;
    </div>

<h3>7.3 Floating-Point Comparisons</h3>
    <p>Never use == with floating-point numbers due to precision issues:</p>

<div class="wpc-code-block">
// Wrong:
if (result == 0.333…) { … }

// Right:
if (fabs(result – expected) < EPSILON) { ... }
    </div>

<h3>7.4 Input Validation</h3>
    <p>Always validate user input to prevent crashes:</p>

<div class="wpc-code-block">
if (scanf(“%d”, &num) != 1) {
    printf(“Invalid input\n”);
    // Clear input buffer
    while (getchar() != ‘\n’);
}
    </div>

<h2>8. Performance Optimization Tips</h2>

<p>Once your calculator works correctly, consider these optimizations:</p>

<table class="wpc-table">
        <thead>
            <tr>
                <th>Technique</th>
                <th>Before</th>
                <th>After</th>
                <th>Improvement</th>
            </tr>
        </thead>
        <tbody>
            <tr>
                <td>Use compound assignments</td>
                <td>x = x + 5;</td>
                <td>x += 5;</td>
                <td>More concise, same performance</td>
            </tr>
            <tr>
                <td>Avoid repeated calculations</td>
                <td>area = 3.14 * r * r;</td>
                <td>area = 3.14 * r_squared;<br>(where r_squared = r * r)</td>
                <td>Faster for repeated use</td>
            </tr>
            <tr>
                <td>Use appropriate data types</td>
                <td>float for financial calculations</td>
                <td>double or fixed-point</td>
                <td>Better precision</td>
            </tr>
            <tr>
                <td>Minimize function calls</td>
                <td>Multiple calls to pow()</td>
                <td>Precompute common powers</td>
                <td>Reduces overhead</td>
            </tr>
        </tbody>
    </table>

<h2>9. Advanced Calculator Features</h2>

<p>Once you’ve mastered basic calculator functionality, consider implementing these advanced features:</p>

<ul>
        <li>Variable storage and recall</li>
        <li>History of calculations</li>
        <li>Unit conversions</li>
        <li>Complex number support</li>
        <li>Graphing capabilities</li>
        <li>Programmable functions</li>
        <li>Matrix operations</li>
        <li>Statistical functions</li>
    </ul>

<h2>10. Learning Resources</h2>

<p>To improve your C programming and debugging skills:</p>

<div class="wpc-authority-link">
        <strong>C Programming Language Standards:</strong> The official ISO C standard documents provide authoritative information about the language specification.
        <a href="https://www.iso.org/standard/74528.html" target="_blank" rel="noopener noreferrer">ISO C Standard (iso.org)</a>
    </div>

<div class="wpc-authority-link">
        <strong>GNU Debugger Documentation:</strong> Comprehensive guide to using GDB for debugging C programs.
        <a href="https://www.gnu.org/software/gdb/documentation/" target="_blank" rel="noopener noreferrer">GDB Documentation (gnu.org)</a>
    </div>

<div class="wpc-authority-link">
        <strong>C Programming FAQ:</strong> Extensive collection of answers to common C programming questions.
        <a href="http://c-faq.com/" target="_blank" rel="noopener noreferrer">C FAQ (c-faq.com)</a>
    </div>

<h2>11. Common C Calculator Code Examples</h2>

<h3>11.1 Basic Arithmetic Calculator</h3>
    <div class="wpc-code-block">
#include <stdio.h>

int main() {
    char operator;
    double num1, num2;

printf(“Enter an operator (+, -, *, /): “);
    scanf(“%c”, &operator);

printf(“Enter two operands: “);
    scanf(“%lf %lf”, &num1, &num2);

switch(operator) {
        case ‘+’:
            printf(“%.2lf + %.2lf = %.2lf\n”, num1, num2, num1 + num2);
            break;
        case ‘-‘:
            printf(“%.2lf – %.2lf = %.2lf\n”, num1, num2, num1 – num2);
            break;
        case ‘*’:
            printf(“%.2lf * %.2lf = %.2lf\n”, num1, num2, num1 * num2);
            break;
        case ‘/’:
            if (num2 != 0.0)
                printf(“%.2lf / %.2lf = %.2lf\n”, num1, num2, num1 / num2);
            else
                printf(“Error! Division by zero.\n”);
            break;
        default:
            printf(“Error! Invalid operator.\n”);
    }

return 0;
}
    </div>

<h3>11.2 Scientific Calculator with Basic Functions</h3>
    <div class="wpc-code-block">
#include <stdio.h>
#include <math.h>

int main() {
    double num, result;
    int choice;

printf(“Scientific Calculator\n”);
    printf(“1. Square Root\n”);
    printf(“2. Power\n”);
    printf(“3. Logarithm (base 10)\n”);
    printf(“4. Natural Logarithm\n”);
    printf(“5. Sine\n”);
    printf(“6. Cosine\n”);
    printf(“7. Tangent\n”);
    printf(“Enter your choice: “);
    scanf(“%d”, &choice);

printf(“Enter number: “);
    scanf(“%lf”, &num);

switch(choice) {
        case 1:
            if (num >= 0) {
                result = sqrt(num);
                printf(“Square root of %.2lf = %.4lf\n”, num, result);
            } else {
                printf(“Error: Negative number for square root\n”);
            }
            break;
        case 2:
            {
                double exponent;
                printf(“Enter exponent: “);
                scanf(“%lf”, &exponent);
                result = pow(num, exponent);
                printf(“%.2lf ^ %.2lf = %.4lf\n”, num, exponent, result);
            }
            break;
        case 3:
            if (num > 0) {
                result = log10(num);
                printf(“log10(%.2lf) = %.4lf\n”, num, result);
            } else {
                printf(“Error: Non-positive number for logarithm\n”);
            }
            break;
        case 4:
            if (num > 0) {
                result = log(num);
                printf(“ln(%.2lf) = %.4lf\n”, num, result);
            } else {
                printf(“Error: Non-positive number for natural logarithm\n”);
            }
            break;
        case 5:
            result = sin(num);
            printf(“sin(%.2lf) = %.4lf\n”, num, result);
            break;
        case 6:
            result = cos(num);
            printf(“cos(%.2lf) = %.4lf\n”, num, result);
            break;
        case 7:
            result = tan(num);
            printf(“tan(%.2lf) = %.4lf\n”, num, result);
            break;
        default:
            printf(“Error: Invalid choice\n”);
    }

return 0;
}
    </div>

<h2>12. Frequently Asked Questions</h2>

<h3>Q: My calculator compiles but gives wrong results. What should I check?</h3>
    <p>A: Verify these common issues:</p>
    <ul>
        <li>Integer division when you need floating-point</li>
        <li>Operator precedence in your expressions</li>
        <li>Correct use of parentheses</li>
        <li>Proper variable initialization</li>
        <li>Accurate input parsing</li>
    </ul>

<h3>Q: Why does my calculator crash when I enter certain inputs?</h3>
    <p>A: Likely causes include:</p>
    <ul>
        <li>Division by zero without checks</li>
        <li>Buffer overflows from unvalidated input</li>
        <li>Accessing array elements out of bounds</li>
        <li>Dereferencing null or invalid pointers</li>
        <li>Stack overflow from excessive recursion</li>
    </ul>

<h3>Q: How can I make my calculator handle very large numbers?</h3>
    <p>A: For numbers beyond standard data type limits:</p>
    <ul>
        <li>Use <code>long long</code> for larger integers</li>
        <li>Use <code>long double</code> for more precise floating-point</li>
        <li>Implement arbitrary-precision arithmetic</li>
        <li>Use libraries like GMP (GNU Multiple Precision)</li>
    </ul>

<h3>Q: Why does my calculator behave differently on different computers?</h3>
    <p>A: Possible reasons:</p>
    <ul>
        <li>Different compiler implementations</li>
        <li>Variations in floating-point handling</li>
        <li>Endianness differences (byte order)</li>
        <li>Different sizes of data types</li>
        <li>Operating system-specific behaviors</li>
    </ul>
    <p>To minimize these issues:</p>
    <ul>
        <li>Use fixed-width integer types from <code>stdint.h</code></li>
        <li>Be explicit about floating-point precision</li>
        <li>Test on multiple platforms</li>
        <li>Follow portable coding practices</li>
    </ul>

<h3>Q: How can I add memory functions to my calculator?</h3>
    <p>A: Implement these features:</p>
    <ul>
        <li>Global variables to store memory values</li>
        <li>Functions for memory recall (MR)</li>
        <li>Functions for memory store (MS)</li>
        <li>Functions for memory add (M+)</li>
        <li>Functions for memory clear (MC)</li>
    </ul>
    <div class="wpc-code-block">
double memory = 0.0;

void memory_store(double value) {
    memory = value;
}

double memory_recall() {
    return memory;
}

void memory_add(double value) {
    memory += value;
}

void memory_clear() {
    memory = 0.0;
}
    </div>
</article>

// Chart initialization
        const ctx = document.getElementById('wpc-chart').getContext('2d');
        let errorChart = null;

calculateBtn.addEventListener('click', function() {
            // Get all input values
            const codeSnippet = document.getElementById('wpc-code-snippet').value;
            const errorMessage = document.getElementById('wpc-error-message').value;
            const compiler = document.getElementById('wpc-compiler').value;
            const compilerFlags = document.getElementById('wpc-compiler-flags').value;
            const os = document.querySelector('input[name="wpc-os"]:checked').value;
            const calculatorType = document.getElementById('wpc-calculator-type').value;

// Simple analysis based on inputs
            const analysis = analyzeCalculatorCode(
                codeSnippet,
                errorMessage,
                compiler,
                compilerFlags,
                os,
                calculatorType
            );

// Display results
            displayResults(analysis);

// Show results section
            resultsDiv.style.display = 'block';

// Scroll to results
            resultsDiv.scrollIntoView({ behavior: 'smooth' });
        });

function analyzeCalculatorCode(code, error, compiler, flags, os, type) {
            const analysis = {
                issues: [],
                suggestions: [],
                statistics: {
                    syntaxErrors: 0,
                    logicalErrors: 0,
                    potentialBugg: 0,
                    warnings: 0
                },
                chartData: {
                    labels: ['Syntax Errors', 'Logical Errors', 'Potential Bugs', 'Warnings'],
                    data: [0, 0, 0, 0],
                    colors: ['#ef4444', '#f97316', '#eab308', '#3b82f6']
                }
            };

// Basic pattern matching for common issues
            if (code.includes('scanf(') && !code.includes('check')) {
                analysis.issues.push("Potential unchecked input from scanf - could lead to buffer overflows or invalid data");
                analysis.statistics.potentialBugg++;
                analysis.chartData.data[2]++;
            }

if (code.includes('/') && !code.includes('!= 0') && !code.includes('denominator')) {
                analysis.issues.push("Possible division by zero risk detected");
                analysis.statistics.potentialBugg++;
                analysis.chartData.data[2]++;
            }

if (code.includes('int ') && code.includes('= ') && code.includes('/') &&
                !code.includes('(double)') && !code.includes('(float)')) {
                analysis.issues.push("Integer division detected where floating-point might be intended");
                analysis.statistics.logicalErrors++;
                analysis.chartData.data[1]++;
            }

if (code.includes('if (') && code.includes('==') && code.includes('float') ||
                code.includes('if (') && code.includes('==') && code.includes('double')) {
                analysis.issues.push("Floating-point equality comparison detected - may cause precision issues");
                analysis.statistics.logicalErrors++;
                analysis.chartData.data[1]++;
            }

if (!code.includes('#include <math.h>') &&
                (code.includes('sqrt') || code.includes('pow') || code.includes('sin') ||
                 code.includes('cos') || code.includes('tan') || code.includes('log'))) {
                analysis.issues.push("Math functions used but math.h not included");
                analysis.statistics.syntaxErrors++;
                analysis.chartData.data[0]++;
            }

if (error.toLowerCase().includes('segmentation fault')) {
                analysis.issues.push("Segmentation fault suggests memory access violation - check array bounds and pointers");
                analysis.statistics.potentialBugg += 2;
                analysis.chartData.data[2] += 2;
            }

if (error.toLowerCase().includes('undefined reference')) {
                analysis.issues.push("Undefined reference suggests missing library or function definition");
                analysis.statistics.syntaxErrors++;
                analysis.chartData.data[0]++;
            }

if (!flags.includes('-Wall') && !flags.includes('-Wextra')) {
                analysis.suggestions.push("Consider adding -Wall -Wextra compiler flags to catch more warnings");
                analysis.statistics.warnings++;
                analysis.chartData.data[3]++;
            }

// Compiler-specific suggestions
            if (compiler === 'gcc' && !flags.includes('-std=')) {
                analysis.suggestions.push("For GCC, consider specifying a C standard with -std=c11 or similar");
            }

// OS-specific suggestions
            if (os === 'windows' && code.includes('\\n') && !code.includes('\r')) {
                analysis.suggestions.push("On Windows, consider using \\r\\n for newlines instead of just \\n");
            }

// Calculator type specific suggestions
            if (type === 'scientific' && !code.includes('#include <math.h>')) {
                analysis.suggestions.push("Scientific calculators typically need math.h for trigonometric and logarithmic functions");
            }

if (type === 'financial' && !code.includes('pow(')) {
                analysis.suggestions.push("Financial calculations often require power functions for compound interest");
            }

// Generate some general suggestions if few issues found
            if (analysis.issues.length === 0 && analysis.suggestions.length === 0) {
                analysis.suggestions.push("Your code appears structurally sound - consider adding more input validation");
                analysis.suggestions.push("Test edge cases like very large numbers, zero, and negative numbers");
                analysis.suggestions.push("Add comments to explain complex calculations for future maintenance");
            }

return analysis;
        }

function displayResults(analysis) {
            // Clear previous results
            resultContent.innerHTML = '';

// Create issues section if there are any
            if (analysis.issues.length > 0) {
                const issuesTitle = document.createElement('h3');
                issuesTitle.textContent = 'Potential Issues Found:';
                resultContent.appendChild(issuesTitle);

const issuesList = document.createElement('ul');
                analysis.issues.forEach(issue => {
                    const item = document.createElement('li');
                    item.textContent = issue;
                    issuesList.appendChild(item);
                });
                resultContent.appendChild(issuesList);
            }

// Create suggestions section if there are any
            if (analysis.suggestions.length > 0) {
                const suggestionsTitle = document.createElement('h3');
                suggestionsTitle.textContent = 'Suggestions for Improvement:';
                resultContent.appendChild(suggestionsTitle);

const suggestionsList = document.createElement('ul');
                analysis.suggestions.forEach(suggestion => {
                    const item = document.createElement('li');
                    item.textContent = suggestion;
                    suggestionsList.appendChild(item);
                });
                resultContent.appendChild(suggestionsList);
            }

// If no issues or suggestions found
            if (analysis.issues.length === 0 && analysis.suggestions.length === 0) {
                const noIssues = document.createElement('p');
                noIssues.textContent = "No obvious issues detected in your calculator code. Your implementation appears correct based on the provided information.";
                resultContent.appendChild(noIssues);
            }

// Create statistics section
            const statsTitle = document.createElement('h3');
            statsTitle.textContent = 'Code Analysis Statistics:';
            resultContent.appendChild(statsTitle);

const statsList = document.createElement('ul');
            const stats = [
                { label: 'Potential syntax errors', value: analysis.statistics.syntaxErrors },
                { label: 'Logical errors detected', value: analysis.statistics.logicalErrors },
                { label: 'Potential bugs found', value: analysis.statistics.potentialBugg },
                { label: 'Compilation warnings suggested', value: analysis.statistics.warnings }
            ];

stats.forEach(stat => {
                const item = document.createElement('li');
                item.innerHTML = `<strong>${stat.label}:</strong> <span class="wpc-result-highlight">${stat.value}</span>`;
                statsList.appendChild(item);
            });
            resultContent.appendChild(statsList);

// Update or create chart
            updateChart(analysis.chartData);
        }

function updateChart(chartData) {
            // Destroy previous chart if it exists
            if (errorChart) {
                errorChart.destroy();
            }

// Create new chart
            errorChart = new Chart(ctx, {
                type: 'doughnut',
                data: {
                    labels: chartData.labels,
                    datasets: [{
                        data: chartData.data,
                        backgroundColor: chartData.colors,
                        borderWidth: 1
                    }]
                },
                options: {
                    responsive: true,
                    maintainAspectRatio: false,
                    plugins: {
                        legend: {
                            position: 'right',
                        },
                        tooltip: {
                            callbacks: {
                                label: function(context) {
                                    return `${context.label}: ${context.raw}`;
                                }
                            }
                        }
                    },
                    animation: {
                        animateScale: true,
                        animateRotate: true
                    }
                }
            });
        }
    });
</script>
		</div>

</article>

</div>

<div class="ct-comments" id="comments">
	
	
	
	
		<div id="respond" class="comment-respond">
		<h2 id="reply-title" class="comment-reply-title">Leave a Reply<span class="ct-cancel-reply"><a rel="nofollow" id="cancel-comment-reply-link" href="/why-is-my-calculator-in-c-not-working/#respond" style="display:none;">Cancel Reply</a></span></h2><form action="https://cal48.calculator.city/wp-comments-post.php" method="post" id="commentform" class="comment-form has-website-field has-labels-inside"><p class="comment-notes"><span id="email-notes">Your email address will not be published.</span> <span class="required-field-message">Required fields are marked <span class="required">*</span></span></p><p class="comment-form-field-input-author">
			<label for="author">Name <b class="required"> *</b></label>
			<input id="author" name="author" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-email">
				<label for="email">Email <b class="required"> *</b></label>
				<input id="email" name="email" type="text" value="" size="30" required='required'>
			</p>
<p class="comment-form-field-input-url">
				<label for="url">Website</label>
				<input id="url" name="url" type="text" value="" size="30">
				</p>

<p class="comment-form-field-textarea">
			<label for="comment">Add Comment<b class="required"> *</b></label>
			<textarea id="comment" name="comment" cols="45" rows="8" required="required">