Fix: Fatal error: Uncaught Error: Call to undefined function error in PHP - Complete Guide

The ‘Fatal error: Uncaught Error: Call to undefined function’ is a common issue in PHP applications that occurs when the PHP interpreter cannot find a function that is being called in your code. This error stops script execution immediately and prevents your application from running properly. Understanding and resolving this error is crucial for building reliable PHP applications that execute without runtime errors.

This comprehensive guide explains what causes the undefined function error, why it happens, and provides multiple solutions to fix and prevent it in your PHP projects with clean code examples and directory structure.

---

What is the ‘Call to undefined function’ Error?

The ‘Call to undefined function’ error occurs when:

• A function is called before it’s defined
• Required files containing the function are not included
• The function exists in a different namespace
• The function is part of an extension that’s not installed
• Autoloader configuration is incorrect
• File paths are incorrect in include/require statements
• The function is defined conditionally but the condition wasn’t met

Common Error Messages:

• Fatal error: Uncaught Error: Call to undefined function my_function()
• Fatal error: Call to undefined function Illuminate\Support\Facades\DB::table()
• Fatal error: Uncaught Error: Call to undefined function dd()
• Fatal error: Call to undefined function array_is_list()
• Fatal error: Uncaught Error: Call to undefined function wp_get_current_user()

---

Understanding the Problem

In PHP, functions must be defined before they can be called. When PHP encounters a function call that doesn’t match any defined function, it throws a fatal error. This can happen due to incorrect file inclusion, namespace issues, missing extensions, or autoloader problems. The error is particularly common in larger applications where functions are spread across multiple files.

Typical PHP Project Structure:

MyPhpApp/
├── composer.json
├── composer.lock
├── index.php
├── config/
│   ├── database.php
│   └── app.php
├── src/
│   ├── Functions/
│   │   ├── helpers.php
│   │   └── utils.php
│   ├── Controllers/
│   │   ├── HomeController.php
│   │   └── UserController.php
│   ├── Models/
│   │   ├── User.php
│   │   └── Product.php
│   └── Services/
│       ├── UserService.php
│       └── EmailService.php
├── vendor/
├── public/
│   └── index.php
├── includes/
│   ├── functions.php
│   └── constants.php
└── tests/
    └── Unit/
        └── FunctionTest.php

---

Solution 1: Proper Function Declaration and Inclusion

The most fundamental approach to prevent undefined function errors is to ensure functions are properly declared and included.

❌ Without Proper Function Declaration:

<?php
// ❌ Calling function before it's defined
echo format_user_name('John', 'Doe'); // ❌ Fatal error: Call to undefined function

// ❌ Function defined after it's called
function format_user_name($first, $last) {
    return $first . ' ' . $last;
}
?>

✅ With Proper Function Declaration:

src/Functions/helpers.php:

<?php
/**
 * Helper functions for the application
 */

// ✅ Define functions before they're used
function format_user_name($first, $last) {
    return ucfirst($first) . ' ' . ucfirst($last);
}

function validate_email($email) {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

function sanitize_input($input) {
    return htmlspecialchars(trim($input), ENT_QUOTES, 'UTF-8');
}

function generate_random_string($length = 10) {
    $characters = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
    $randomString = '';
    for ($i = 0; $i < $length; $i++) {
        $randomString .= $characters[rand(0, strlen($characters) - 1)];
    }
    return $randomString;
}

function get_current_timestamp() {
    return date('Y-m-d H:i:s');
}

function format_currency($amount, $currency = 'USD') {
    return number_format($amount, 2) . ' ' . $currency;
}

function array_get($array, $key, $default = null) {
    if (!is_array($array)) {
        return $default;
    }
    
    if (array_key_exists($key, $array)) {
        return $array[$key];
    }
    
    foreach (explode('.', $key) as $segment) {
        if (!is_array($array) || !array_key_exists($segment, $array)) {
            return $default;
        }
        $array = $array[$segment];
    }
    
    return $array;
}

function array_set(&$array, $key, $value) {
    if (!is_array($array)) {
        $array = [];
    }
    
    $keys = explode('.', $key);
    $current = &$array;
    
    foreach ($keys as $i => $key) {
        if ($i === count($keys) - 1) {
            $current[$key] = $value;
        } else {
            if (!isset($current[$key]) || !is_array($current[$key])) {
                $current[$key] = [];
            }
            $current = &$current[$key];
        }
    }
}

function is_valid_url($url) {
    return filter_var($url, FILTER_VALIDATE_URL) !== false;
}

function get_file_extension($filename) {
    return pathinfo($filename, PATHINFO_EXTENSION);
}

function format_bytes($size, $precision = 2) {
    $units = array('B', 'KB', 'MB', 'GB', 'TB');
    
    for ($i = 0; $size > 1024 && $i < count($units) - 1; $i++) {
        $size /= 1024;
    }
    
    return round($size, $precision) . ' ' . $units[$i];
}
?>

src/Functions/utils.php:

<?php
/**
 * Utility functions for the application
 */

function log_message($message, $level = 'info') {
    $timestamp = date('Y-m-d H:i:s');
    $logEntry = "[$timestamp] [$level] $message" . PHP_EOL;
    file_put_contents(__DIR__ . '/../../logs/app.log', $logEntry, FILE_APPEND | LOCK_EX);
}

function get_client_ip() {
    $ipKeys = ['HTTP_X_FORWARDED_FOR', 'HTTP_X_REAL_IP', 'HTTP_CLIENT_IP', 'REMOTE_ADDR'];
    
    foreach ($ipKeys as $key) {
        if (!empty($_SERVER[$key])) {
            $ip = $_SERVER[$key];
            if (strpos($ip, ',') !== false) {
                $ip = trim(explode(',', $ip)[0]);
            }
            if (filter_var($ip, FILTER_VALIDATE_IP)) {
                return $ip;
            }
        }
    }
    
    return '0.0.0.0';
}

function calculate_age($dateOfBirth) {
    $dob = new DateTime($dateOfBirth);
    $now = new DateTime();
    $interval = $now->diff($dob);
    return $interval->y;
}

function generate_slug($text) {
    $text = strtolower($text);
    $text = preg_replace('/[^a-z0-9\s-]/', '', $text);
    $text = preg_replace('/[\s-]+/', '-', $text);
    return trim($text, '-');
}

function is_ajax_request() {
    return !empty($_SERVER['HTTP_X_REQUESTED_WITH']) && 
           strtolower($_SERVER['HTTP_X_REQUESTED_WITH']) == 'xmlhttprequest';
}

function get_user_agent() {
    return $_SERVER['HTTP_USER_AGENT'] ?? 'Unknown';
}

function is_mobile_device() {
    $userAgent = get_user_agent();
    $mobileKeywords = ['Mobile', 'Android', 'iPhone', 'iPad', 'iPod', 'BlackBerry', 'Windows Phone'];
    
    foreach ($mobileKeywords as $keyword) {
        if (stripos($userAgent, $keyword) !== false) {
            return true;
        }
    }
    
    return false;
}

function encrypt_data($data, $key) {
    $ivLength = openssl_cipher_iv_length('aes-256-cbc');
    $iv = openssl_random_pseudo_bytes($ivLength);
    $encrypted = openssl_encrypt($data, 'aes-256-cbc', $key, 0, $iv);
    return base64_encode($iv . $encrypted);
}

function decrypt_data($encryptedData, $key) {
    $data = base64_decode($encryptedData);
    $ivLength = openssl_cipher_iv_length('aes-256-cbc');
    $iv = substr($data, 0, $ivLength);
    $encrypted = substr($data, $ivLength);
    return openssl_decrypt($encrypted, 'aes-256-cbc', $key, 0, $iv);
}

function validate_password_strength($password) {
    $hasMinLength = strlen($password) >= 8;
    $hasUpperCase = preg_match('/[A-Z]/', $password);
    $hasLowerCase = preg_match('/[a-z]/', $password);
    $hasNumbers = preg_match('/[0-9]/', $password);
    $hasSpecialChar = preg_match('/[^A-Za-z0-9]/', $password);
    
    return $hasMinLength && $hasUpperCase && $hasLowerCase && $hasNumbers && $hasSpecialChar;
}
?>

public/index.php:

<?php
/**
 * Main application entry point
 */

// ✅ Include necessary files before using functions
require_once __DIR__ . '/../src/Functions/helpers.php';
require_once __DIR__ . '/../src/Functions/utils.php';

// ✅ Now we can safely use the functions
$userName = format_user_name('john', 'doe');
echo "Formatted name: " . $userName . "\n";

$email = 'test@example.com';
if (validate_email($email)) {
    echo "Email is valid: " . $email . "\n";
} else {
    echo "Email is invalid: " . $email . "\n";
}

// ✅ Use utility functions
$clientIp = get_client_ip();
echo "Client IP: " . $clientIp . "\n";

$slug = generate_slug('This is a Sample Title');
echo "Generated slug: " . $slug . "\n";

// ✅ Example of using functions in a more complex scenario
function process_user_data($userData) {
    // ✅ Use helper functions to process data
    $userData['name'] = sanitize_input($userData['name']);
    $userData['email'] = sanitize_input($userData['email']);
    
    if (!validate_email($userData['email'])) {
        throw new InvalidArgumentException('Invalid email address');
    }
    
    $userData['slug'] = generate_slug($userData['name']);
    $userData['created_at'] = get_current_timestamp();
    
    return $userData;
}

// ✅ Test the function
try {
    $testUser = [
        'name' => '  John Doe  ',
        'email' => 'john.doe@example.com',
        'age' => 30
    ];
    
    $processedUser = process_user_data($testUser);
    echo "Processed user: " . json_encode($processedUser) . "\n";
} catch (Exception $e) {
    echo "Error processing user: " . $e->getMessage() . "\n";
}
?>

---

Solution 2: Proper File Inclusion and Autoloading

Use proper file inclusion methods and implement autoloading for better function management.

composer.json:

{
    "name": "mycompany/myphpapp",
    "description": "A sample PHP application",
    "type": "project",
    "require": {
        "php": ">=8.0"
    },
    "autoload": {
        "files": [
            "src/Functions/helpers.php",
            "src/Functions/utils.php"
        ],
        "psr-4": {
            "MyApp\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "MyApp\\Tests\\": "tests/"
        }
    },
    "scripts": {
        "post-install-cmd": [
            "@php -r \"file_exists('.env') || copy('.env.example', '.env');\""
        ]
    }
}

src/Bootstrap.php:

<?php
/**
 * Application bootstrap file
 */

namespace MyApp;

class Bootstrap
{
    /**
     * Initialize the application
     */
    public static function init(): void
    {
        // ✅ Set error reporting
        error_reporting(E_ALL);
        ini_set('display_errors', 1);
        
        // ✅ Set default timezone
        date_default_timezone_set('UTC');
        
        // ✅ Register autoloader if not using Composer
        if (!class_exists('Composer\Autoload\ClassLoader')) {
            self::registerAutoloader();
        }
        
        // ✅ Initialize session if needed
        if (session_status() === PHP_SESSION_NONE) {
            session_start();
        }
        
        // ✅ Load configuration
        self::loadConfiguration();
    }
    
    /**
     * Register custom autoloader
     */
    private static function registerAutoloader(): void
    {
        spl_autoload_register(function ($class) {
            // ✅ Define base directory for the namespace prefix
            $baseDir = __DIR__ . '/';
            
            // ✅ Does the class use the namespace prefix?
            $len = strlen(__NAMESPACE__);
            if (strncmp(__NAMESPACE__, $class, $len) !== 0) {
                // ✅ No, move to the next registered autoloader
                return;
            }
            
            // ✅ Get the relative class name
            $relativeClass = substr($class, $len);
            
            // ✅ Replace the namespace prefix with the base directory, replace namespace
            // separators with directory separators in the relative class name, append
            // with .php
            $file = $baseDir . str_replace('\\', '/', $relativeClass) . '.php';
            
            // ✅ If the file exists, require it
            if (file_exists($file)) {
                require $file;
            }
        });
    }
    
    /**
     * Load application configuration
     */
    private static function loadConfiguration(): void
    {
        // ✅ Load environment variables
        if (file_exists(__DIR__ . '/../.env')) {
            $lines = file(__DIR__ . '/../.env', FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
            foreach ($lines as $line) {
                if (strpos($line, '=') !== false && strpos($line, '#') !== 0) {
                    list($key, $value) = explode('=', $line, 2);
                    $_ENV[trim($key)] = trim($value);
                    putenv(sprintf('%s=%s', trim($key), trim($value)));
                }
            }
        }
    }
}
?>

src/Controllers/HomeController.php:

<?php
/**
 * Home controller
 */

namespace MyApp\Controllers;

use MyApp\Bootstrap;

class HomeController
{
    public function __construct()
    {
        // ✅ Initialize application if not already done
        Bootstrap::init();
    }
    
    public function index()
    {
        // ✅ Use functions that are autoloaded
        $data = [
            'title' => 'Home Page',
            'timestamp' => get_current_timestamp(), // ✅ Function from helpers.php
            'client_ip' => get_client_ip(), // ✅ Function from utils.php
            'is_mobile' => is_mobile_device(), // ✅ Function from utils.php
            'user_agent' => get_user_agent() // ✅ Function from utils.php
        ];
        
        return $this->render('home/index.php', $data);
    }
    
    public function about()
    {
        $data = [
            'title' => 'About Us',
            'current_year' => date('Y'),
            'app_name' => $_ENV['APP_NAME'] ?? 'MyApp'
        ];
        
        return $this->render('home/about.php', $data);
    }
    
    private function render($template, $data = [])
    {
        // ✅ Extract data to local variables
        extract($data);
        
        // ✅ Start output buffering
        ob_start();
        
        // ✅ Include the template
        include __DIR__ . '/../../views/' . $template;
        
        // ✅ Get the output and clean the buffer
        $content = ob_get_clean();
        
        // ✅ Return the rendered content
        return $content;
    }
    
    // ✅ Additional controller methods
    public function contact()
    {
        if ($_SERVER['REQUEST_METHOD'] === 'POST') {
            return $this->handleContactForm();
        }
        
        $data = [
            'title' => 'Contact Us',
            'csrf_token' => $this->generateCsrfToken()
        ];
        
        return $this->render('home/contact.php', $data);
    }
    
    private function handleContactForm()
    {
        // ✅ Validate and sanitize input
        $name = sanitize_input($_POST['name'] ?? '');
        $email = sanitize_input($_POST['email'] ?? '');
        $message = sanitize_input($_POST['message'] ?? '');
        
        // ✅ Validate email
        if (!validate_email($email)) {
            return json_encode(['success' => false, 'message' => 'Invalid email address']);
        }
        
        // ✅ Validate other fields
        if (empty($name) || empty($message)) {
            return json_encode(['success' => false, 'message' => 'All fields are required']);
        }
        
        // ✅ Process the contact form (save to database, send email, etc.)
        $contactData = [
            'name' => $name,
            'email' => $email,
            'message' => $message,
            'ip_address' => get_client_ip(),
            'created_at' => get_current_timestamp()
        ];
        
        // ✅ In a real application, you would save this to a database
        // For now, just return success
        return json_encode(['success' => true, 'message' => 'Message sent successfully']);
    }
    
    private function generateCsrfToken()
    {
        if (!isset($_SESSION['csrf_token'])) {
            $_SESSION['csrf_token'] = generate_random_string(32);
        }
        return $_SESSION['csrf_token'];
    }
}
?>

---

Solution 3: Namespace and Use Statement Management

Properly manage namespaces and use statements to avoid function conflicts.

src/Services/UserService.php:

<?php
/**
 * User service class
 */

namespace MyApp\Services;

use MyApp\Models\User;
use function MyApp\Functions\{format_user_name, validate_email, sanitize_input};
use function MyApp\Functions\get_current_timestamp;

class UserService
{
    /**
     * Create a new user
     */
    public function createUser(array $userData): array
    {
        // ✅ Validate required fields
        if (empty($userData['name']) || empty($userData['email'])) {
            throw new \InvalidArgumentException('Name and email are required');
        }
        
        // ✅ Sanitize input
        $userData['name'] = sanitize_input($userData['name']);
        $userData['email'] = sanitize_input($userData['email']);
        
        // ✅ Validate email
        if (!validate_email($userData['email'])) {
            throw new \InvalidArgumentException('Invalid email address');
        }
        
        // ✅ Format the name
        $userData['formatted_name'] = format_user_name($userData['first_name'] ?? '', $userData['last_name'] ?? $userData['name']);
        
        // ✅ Set creation timestamp
        $userData['created_at'] = get_current_timestamp();
        
        // ✅ In a real application, you would save this to a database
        // For now, just return the processed data
        return $userData;
    }
    
    /**
     * Update user information
     */
    public function updateUser(int $userId, array $userData): array
    {
        // ✅ Validate user ID
        if ($userId <= 0) {
            throw new \InvalidArgumentException('Invalid user ID');
        }
        
        // ✅ Process the update data
        $processedData = [];
        
        if (isset($userData['name'])) {
            $processedData['name'] = sanitize_input($userData['name']);
        }
        
        if (isset($userData['email'])) {
            $email = sanitize_input($userData['email']);
            if (!validate_email($email)) {
                throw new \InvalidArgumentException('Invalid email address');
            }
            $processedData['email'] = $email;
        }
        
        if (isset($userData['name'])) {
            $processedData['formatted_name'] = format_user_name($userData['name'], '');
        }
        
        $processedData['updated_at'] = get_current_timestamp();
        
        // ✅ In a real application, you would update the database
        return $processedData;
    }
    
    /**
     * Validate user data
     */
    public function validateUserData(array $userData): bool
    {
        // ✅ Check required fields
        $requiredFields = ['name', 'email'];
        foreach ($requiredFields as $field) {
            if (empty($userData[$field])) {
                return false;
            }
        }
        
        // ✅ Validate email
        if (!validate_email($userData['email'])) {
            return false;
        }
        
        // ✅ Sanitize and validate other fields as needed
        $userData['name'] = sanitize_input($userData['name']);
        
        return true;
    }
    
    /**
     * Generate user slug
     */
    public function generateUserSlug(string $name): string
    {
        // ✅ Use utility function to generate slug
        return generate_slug($name); // This would need to be imported or accessed differently
    }
    
    /**
     * Format user display information
     */
    public function formatUserDisplay(array $user): array
    {
        $formatted = $user;
        
        // ✅ Format name if available
        if (isset($user['first_name']) && isset($user['last_name'])) {
            $formatted['display_name'] = format_user_name($user['first_name'], $user['last_name']);
        } elseif (isset($user['name'])) {
            $formatted['display_name'] = format_user_name($user['name'], '');
        }
        
        return $formatted;
    }
    
    /**
     * Check if user is active
     */
    public function isUserActive(array $user): bool
    {
        // ✅ Check if user is active based on various criteria
        if (!isset($user['is_active'])) {
            return false;
        }
        
        return (bool) $user['is_active'];
    }
    
    /**
     * Get user age from birth date
     */
    public function getUserAge(string $birthDate): int
    {
        // ✅ This would use a utility function if available
        $dob = new \DateTime($birthDate);
        $now = new \DateTime();
        $interval = $now->diff($dob);
        return $interval->y;
    }
}
?>

src/Models/User.php:

<?php
/**
 * User model
 */

namespace MyApp\Models;

use MyApp\Services\UserService;

class User
{
    private array $attributes = [];
    private UserService $userService;
    
    public function __construct(array $attributes = [])
    {
        $this->attributes = $attributes;
        $this->userService = new UserService();
    }
    
    public function __get(string $name)
    {
        return $this->attributes[$name] ?? null;
    }
    
    public function __set(string $name, $value): void
    {
        $this->attributes[$name] = $value;
    }
    
    public function __isset(string $name): bool
    {
        return isset($this->attributes[$name]);
    }
    
    public function __unset(string $name): void
    {
        unset($this->attributes[$name]);
    }
    
    /**
     * Save the user to the database
     */
    public function save(): bool
    {
        // ✅ Validate the user data before saving
        if (!$this->userService->validateUserData($this->attributes)) {
            throw new \InvalidArgumentException('Invalid user data');
        }
        
        // ✅ In a real application, you would save to a database
        // For now, just return true
        return true;
    }
    
    /**
     * Format the user for display
     */
    public function formatForDisplay(): array
    {
        return $this->userService->formatUserDisplay($this->attributes);
    }
    
    /**
     * Check if the user is active
     */
    public function isActive(): bool
    {
        return $this->userService->isUserActive($this->attributes);
    }
    
    /**
     * Get the user's age
     */
    public function getAge(): int
    {
        if (!isset($this->attributes['birth_date'])) {
            throw new \LogicException('Birth date is required to calculate age');
        }
        
        return $this->userService->getUserAge($this->attributes['birth_date']);
    }
    
    /**
     * Get all user attributes
     */
    public function toArray(): array
    {
        return $this->attributes;
    }
    
    /**
     * Create a new user instance
     */
    public static function create(array $attributes): self
    {
        $user = new self($attributes);
        
        // ✅ Validate before creating
        $userService = new UserService();
        if (!$userService->validateUserData($attributes)) {
            throw new \InvalidArgumentException('Invalid user data');
        }
        
        return $user;
    }
}
?>

---

Solution 4: Conditional Function Definition

Use conditional function definitions to prevent redeclaration errors while ensuring functions exist.

src/Functions/conditional.php:

<?php
/**
 * Conditionally defined functions to prevent redeclaration errors
 */

// ✅ Only define function if it doesn't already exist
if (!function_exists('array_is_list')) {
    /**
     * Polyfill for array_is_list function (available in PHP 8.1+)
     */
    function array_is_list(array $array): bool
    {
        if ($array === []) {
            return true;
        }
        
        $i = 0;
        foreach ($array as $key => $value) {
            if ($key !== $i++) {
                return false;
            }
        }
        
        return true;
    }
}

if (!function_exists('str_contains')) {
    /**
     * Polyfill for str_contains function (available in PHP 8.0+)
     */
    function str_contains(string $haystack, string $needle): bool
    {
        return $needle !== '' && mb_strpos($haystack, $needle) !== false;
    }
}

if (!function_exists('str_starts_with')) {
    /**
     * Polyfill for str_starts_with function (available in PHP 8.0+)
     */
    function str_starts_with(string $haystack, string $needle): bool
    {
        return $needle !== '' && mb_strpos($haystack, $needle) === 0;
    }
}

if (!function_exists('str_ends_with')) {
    /**
     * Polyfill for str_ends_with function (available in PHP 8.0+)
     */
    function str_ends_with(string $haystack, string $needle): bool
    {
        return $needle !== '' && mb_strrpos($haystack, $needle, 0, 'UTF-8') === mb_strlen($haystack, 'UTF-8') - mb_strlen($needle, 'UTF-8');
    }
}

if (!function_exists('dd')) {
    /**
     * Dump and die function for debugging
     */
    function dd(...$vars): void
    {
        foreach ($vars as $var) {
            var_dump($var);
        }
        die(1);
    }
}

if (!function_exists('dump')) {
    /**
     * Dump function for debugging
     */
    function dump(...$vars): void
    {
        foreach ($vars as $var) {
            var_dump($var);
        }
    }
}

if (!function_exists('env')) {
    /**
     * Get environment variable with optional default
     */
    function env(string $key, $default = null)
    {
        $value = $_ENV[$key] ?? $_SERVER[$key] ?? getenv($key);
        
        if ($value === false) {
            return $default;
        }
        
        switch (strtolower($value)) {
            case 'true':
            case '(true)':
                return true;
            case 'false':
            case '(false)':
                return false;
            case 'empty':
            case '(empty)':
                return '';
            case 'null':
            case '(null)':
                return null;
        }
        
        if (($valueLength = strlen($value)) > 1 && $value[0] === '"' && $value[$valueLength - 1] === '"') {
            return substr($value, 1, -1);
        }
        
        return $value;
    }
}

if (!function_exists('config')) {
    /**
     * Get configuration value
     */
    function config(string $key, $default = null)
    {
        static $config = null;
        
        if ($config === null) {
            $configFile = __DIR__ . '/../../config/app.php';
            $config = file_exists($configFile) ? include $configFile : [];
        }
        
        if (strpos($key, '.') !== false) {
            $keys = explode('.', $key);
            $value = $config;
            
            foreach ($keys as $segment) {
                if (!is_array($value) || !array_key_exists($segment, $value)) {
                    return $default;
                }
                $value = $value[$segment];
            }
            
            return $value;
        }
        
        return $config[$key] ?? $default;
    }
}

if (!function_exists('base_path')) {
    /**
     * Get the base path of the application
     */
    function base_path(string $path = ''): string
    {
        return __DIR__ . '/../../' . ltrim($path, '/');
    }
}

if (!function_exists('public_path')) {
    /**
     * Get the public path of the application
     */
    function public_path(string $path = ''): string
    {
        return __DIR__ . '/../../public/' . ltrim($path, '/');
    }
}
?>

---

Solution 5: Error Handling and Debugging

Implement proper error handling and debugging techniques to identify undefined function errors.

src/ErrorHandler.php:

<?php
/**
 * Error handler for undefined function errors
 */

namespace MyApp;

class ErrorHandler
{
    /**
     * Register error handlers
     */
    public static function register(): void
    {
        set_error_handler([self::class, 'handleError']);
        set_exception_handler([self::class, 'handleException']);
        register_shutdown_function([self::class, 'handleShutdown']);
    }
    
    /**
     * Handle PHP errors
     */
    public static function handleError(int $severity, string $message, string $file = '', int $line = 0): bool
    {
        // ✅ Check if this is an undefined function error
        if (strpos($message, 'Call to undefined function') !== false) {
            self::logUndefinedFunctionError($message, $file, $line);
        }
        
        // ✅ For fatal errors, convert to exception
        if ($severity & (E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR)) {
            throw new \ErrorException($message, 0, $severity, $file, $line);
        }
        
        // ✅ Don't execute PHP internal error handler
        return true;
    }
    
    /**
     * Handle uncaught exceptions
     */
    public static function handleException(\Throwable $exception): void
    {
        if (strpos($exception->getMessage(), 'Call to undefined function') !== false) {
            self::logUndefinedFunctionError($exception->getMessage(), $exception->getFile(), $exception->getLine());
        }
        
        // ✅ Log the exception
        error_log("Uncaught exception: " . $exception->getMessage() . " in " . $exception->getFile() . " on line " . $exception->getLine());
        
        // ✅ In development, show detailed error
        if (env('APP_ENV') === 'development') {
            echo "<h1>Uncaught Exception</h1>";
            echo "<p><strong>Message:</strong> " . htmlspecialchars($exception->getMessage()) . "</p>";
            echo "<p><strong>File:</strong> " . htmlspecialchars($exception->getFile()) . "</p>";
            echo "<p><strong>Line:</strong> " . $exception->getLine() . "</p>";
            echo "<pre>" . htmlspecialchars($exception->getTraceAsString()) . "</pre>";
        } else {
            // ✅ In production, show generic error
            http_response_code(500);
            echo "<h1>Internal Server Error</h1>";
            echo "<p>An error occurred while processing your request.</p>";
        }
    }
    
    /**
     * Handle shutdown (for fatal errors that don't trigger error handlers)
     */
    public static function handleShutdown(): void
    {
        $error = error_get_last();
        
        if ($error && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR])) {
            if (strpos($error['message'], 'Call to undefined function') !== false) {
                self::logUndefinedFunctionError($error['message'], $error['file'], $error['line']);
            }
            
            // ✅ Log the fatal error
            error_log("Fatal error: " . $error['message'] . " in " . $error['file'] . " on line " . $error['line']);
            
            // ✅ Show appropriate error page
            if (env('APP_ENV') === 'development') {
                echo "<h1>Fatal Error</h1>";
                echo "<p><strong>Message:</strong> " . htmlspecialchars($error['message']) . "</p>";
                echo "<p><strong>File:</strong> " . htmlspecialchars($error['file']) . "</p>";
                echo "<p><strong>Line:</strong> " . $error['line'] . "</p>";
            } else {
                http_response_code(500);
                echo "<h1>Internal Server Error</h1>";
                echo "<p>A fatal error occurred while processing your request.</p>";
            }
        }
    }
    
    /**
     * Log undefined function errors with additional context
     */
    private static function logUndefinedFunctionError(string $message, string $file, int $line): void
    {
        $context = [
            'timestamp' => date('Y-m-d H:i:s'),
            'error_type' => 'undefined_function',
            'message' => $message,
            'file' => $file,
            'line' => $line,
            'included_files' => get_included_files(),
            'defined_functions' => get_defined_functions(),
            'request_uri' => $_SERVER['REQUEST_URI'] ?? '',
            'request_method' => $_SERVER['REQUEST_METHOD'] ?? '',
            'user_agent' => $_SERVER['HTTP_USER_AGENT'] ?? '',
            'ip_address' => $_SERVER['REMOTE_ADDR'] ?? ''
        ];
        
        $logMessage = json_encode($context, JSON_PRETTY_PRINT);
        error_log($logMessage, 3, __DIR__ . '/../../logs/undefined_functions.log');
    }
    
    /**
     * Check if a function exists and provide debugging information
     */
    public static function checkFunctionExists(string $functionName): array
    {
        $result = [
            'function_name' => $functionName,
            'exists' => function_exists($functionName),
            'defined_functions' => get_defined_functions(),
            'included_files' => get_included_files(),
            'suggestions' => []
        ];
        
        if (!$result['exists']) {
            // ✅ Provide suggestions for similar function names
            $allFunctions = array_merge(
                $result['defined_functions']['user'],
                $result['defined_functions']['internal']
            );
            
            $similar = [];
            foreach ($allFunctions as $func) {
                $similarity = similar_text($functionName, $func, $percent);
                if ($percent > 70) { // More than 70% similarity
                    $similar[] = ['function' => $func, 'similarity' => $percent];
                }
            }
            
            // ✅ Sort by similarity
            usort($similar, function ($a, $b) {
                return $b['similarity'] <=> $a['similarity'];
            });
            
            $result['suggestions'] = array_slice($similar, 0, 5); // Top 5 suggestions
        }
        
        return $result;
    }
}
?>

public/error-checker.php:

<?php
/**
 * Error checking utility page
 */

require_once __DIR__ . '/../vendor/autoload.php';
require_once __DIR__ . '/../src/Functions/helpers.php';
require_once __DIR__ . '/../src/Functions/utils.php';
require_once __DIR__ . '/../src/Functions/conditional.php';

use MyApp\ErrorHandler;

// ✅ Register error handlers
ErrorHandler::register();

// ✅ Check for undefined functions
if (isset($_GET['check_function'])) {
    $functionName = $_GET['check_function'];
    $result = ErrorHandler::checkFunctionExists($functionName);
    
    header('Content-Type: application/json');
    echo json_encode($result, JSON_PRETTY_PRINT);
    exit;
}

// ✅ Test function existence
$testFunctions = [
    'format_user_name',
    'validate_email', 
    'sanitize_input',
    'array_is_list', // This might not exist in older PHP versions
    'non_existent_function'
];

echo "<h1>Function Existence Check</h1>";
echo "<table border='1'>";
echo "<tr><th>Function Name</th><th>Exists</th><th>Suggestions</th></tr>";

foreach ($testFunctions as $func) {
    $result = ErrorHandler::checkFunctionExists($func);
    $exists = $result['exists'] ? 'Yes' : 'No';
    $suggestions = !empty($result['suggestions']) ? 
        implode(', ', array_column($result['suggestions'], 'function')) : 'None';
    
    echo "<tr>";
    echo "<td>{$func}</td>";
    echo "<td>{$exists}</td>";
    echo "<td>{$suggestions}</td>";
    echo "</tr>";
}

echo "</table>";

// ✅ Show included files
echo "<h2>Included Files</h2>";
$includedFiles = get_included_files();
foreach ($includedFiles as $file) {
    echo "<p>" . htmlspecialchars($file) . "</p>";
}

// ✅ Show defined functions
echo "<h2>Defined Functions</h2>";
$definedFunctions = get_defined_functions();
echo "<h3>User Functions:</h3>";
foreach ($definedFunctions['user'] as $func) {
    echo "<p>" . htmlspecialchars($func) . "</p>";
}

echo "<h3>Internal Functions:</h3>";
foreach (array_slice($definedFunctions['internal'], 0, 20) as $func) { // Show first 20
    echo "<p>" . htmlspecialchars($func) . "</p>";
}
?>

---

Working Code Examples

Complete PHP Application with Proper Function Management:

<?php
/**
 * Complete example of a PHP application with proper function management
 */

// ✅ Include Composer autoloader
require_once __DIR__ . '/../vendor/autoload.php';

// ✅ Initialize the application
use MyApp\Bootstrap;
use MyApp\Controllers\HomeController;
use MyApp\ErrorHandler;

// ✅ Register error handlers
ErrorHandler::register();

// ✅ Initialize the application
Bootstrap::init();

// ✅ Create and run the controller
$controller = new HomeController();
echo $controller->index();

// ✅ Example of using functions safely
echo "<h2>Function Usage Examples</h2>";

// ✅ Use helper functions
$userName = format_user_name('john', 'doe');
echo "<p>Formatted name: " . htmlspecialchars($userName) . "</p>";

// ✅ Use validation functions
$email = 'test@example.com';
$isValid = validate_email($email);
echo "<p>Email '{$email}' is " . ($isValid ? 'valid' : 'invalid') . "</p>";

// ✅ Use utility functions
$clientIp = get_client_ip();
echo "<p>Client IP: " . htmlspecialchars($clientIp) . "</p>";

// ✅ Use conditional functions (polyfills)
if (function_exists('array_is_list')) {
    $list = [1, 2, 3];
    $isList = array_is_list($list);
    echo "<p>Array is list: " . ($isList ? 'Yes' : 'No') . "</p>";
}

// ✅ Use debugging functions
if (function_exists('dd')) {
    // dd('Debug output'); // Uncomment to test
}

echo "<p>Current timestamp: " . get_current_timestamp() . "</p>";
echo "<p>Random string: " . generate_random_string(16) . "</p>";
echo "<p>Slug: " . generate_slug('Sample Title for URL') . "</p>";
?>

Unit Test Example:

<?php
/**
 * Unit tests for function definitions
 */

require_once __DIR__ . '/../vendor/autoload.php';
require_once __DIR__ . '/../src/Functions/helpers.php';
require_once __DIR__ . '/../src/Functions/utils.php';
require_once __DIR__ . '/../src/Functions/conditional.php';

use PHPUnit\Framework\TestCase;

class FunctionTest extends TestCase
{
    public function testFormatUserName()
    {
        // ✅ Test the format_user_name function
        $result = format_user_name('john', 'doe');
        $this->assertEquals('John Doe', $result);
        
        $result = format_user_name('JANE', 'SMITH');
        $this->assertEquals('Jane Smith', $result);
    }
    
    public function testValidateEmail()
    {
        // ✅ Test the validate_email function
        $this->assertTrue(validate_email('test@example.com'));
        $this->assertFalse(validate_email('invalid-email'));
        $this->assertFalse(validate_email(''));
    }
    
    public function testSanitizeInput()
    {
        // ✅ Test the sanitize_input function
        $input = '<script>alert("xss")</script>Test';
        $result = sanitize_input($input);
        $this->assertEquals('&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;Test', $result);
    }
    
    public function testGenerateRandomString()
    {
        // ✅ Test the generate_random_string function
        $result = generate_random_string(10);
        $this->assertEquals(10, strlen($result));
        $this->assertIsString($result);
    }
    
    public function testGetCurrentTimestamp()
    {
        // ✅ Test the get_current_timestamp function
        $result = get_current_timestamp();
        $this->assertMatchesRegularExpression('/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/', $result);
    }
    
    public function testArrayGet()
    {
        // ✅ Test the array_get function
        $array = ['user' => ['name' => 'John', 'age' => 30]];
        $this->assertEquals('John', array_get($array, 'user.name'));
        $this->assertEquals(30, array_get($array, 'user.age'));
        $this->assertNull(array_get($array, 'user.email'));
        $this->assertEquals('default', array_get($array, 'user.email', 'default'));
    }
    
    public function testIsAjaxRequest()
    {
        // ✅ Test the is_ajax_request function
        // This would require setting the appropriate server variable
        $_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';
        $this->assertTrue(is_ajax_request());
        
        unset($_SERVER['HTTP_X_REQUESTED_WITH']);
        $this->assertFalse(is_ajax_request());
    }
    
    public function testConditionalFunctions()
    {
        // ✅ Test that conditional functions exist
        $this->assertTrue(function_exists('array_is_list'));
        $this->assertTrue(function_exists('str_contains'));
        $this->assertTrue(function_exists('str_starts_with'));
        $this->assertTrue(function_exists('str_ends_with'));
        $this->assertTrue(function_exists('dd'));
        $this->assertTrue(function_exists('dump'));
        $this->assertTrue(function_exists('env'));
        $this->assertTrue(function_exists('config'));
    }
    
    public function testGenerateSlug()
    {
        // ✅ Test the generate_slug function
        $this->assertEquals('hello-world', generate_slug('Hello World'));
        $this->assertEquals('sample-title', generate_slug('Sample Title!@#'));
        $this->assertEquals('test', generate_slug('  Test  '));
    }
    
    public function testFormatBytes()
    {
        // ✅ Test the format_bytes function
        $this->assertEquals('1024 B', format_bytes(1024));
        $this->assertEquals('1 KB', format_bytes(1024 * 2));
        $this->assertEquals('1.50 MB', format_bytes(1024 * 1024 * 1.5));
    }
}
?>

---

Best Practices for Function Management

1. Always Include Required Files

<?php
// ✅ Always include files that define the functions you need
require_once 'functions/helpers.php';
require_once 'functions/utils.php';

// ✅ Now you can safely use the functions
$result = my_helper_function();
?>

2. Use Composer Autoloader

{
    "autoload": {
        "files": [
            "src/Functions/helpers.php"
        ],
        "psr-4": {
            "MyApp\\": "src/"
        }
    }
}

3. Check Function Existence Before Calling

<?php
// ✅ Check if function exists before calling
if (function_exists('my_function')) {
    my_function();
} else {
    // ✅ Handle the case where function doesn't exist
    echo "Function not available";
}
?>

4. Use Conditional Function Definitions

<?php
// ✅ Only define function if it doesn't exist
if (!function_exists('my_function')) {
    function my_function() {
        // ✅ Function implementation
    }
}
?>

5. Organize Functions Logically

<?php
// ✅ Group related functions in separate files
// helpers.php - general helper functions
// validation.php - validation functions  
// formatting.php - formatting functions
?>

6. Use Proper Error Handling

<?php
try {
    $result = my_function();
} catch (Error $e) {
    if (strpos($e->getMessage(), 'Call to undefined function') !== false) {
        // ✅ Handle undefined function error
        error_log('Undefined function called: ' . $e->getMessage());
        // ✅ Provide fallback or redirect
    }
}
?>

---

Debugging Steps

Step 1: Check Function Name Spelling

<?php
// ✅ Verify the function name is spelled correctly
// Wrong: my_funtion()
// Correct: my_function()
?>

Step 2: Verify File Inclusion

<?php
// ✅ Check if the file containing the function is included
var_dump(get_included_files()); // ✅ See which files are loaded
?>

Step 3: Check Function Existence

<?php
// ✅ Check if function exists
var_dump(function_exists('my_function'));
?>

Step 4: Check Defined Functions

<?php
// ✅ See all defined functions
$functions = get_defined_functions();
print_r($functions['user']); // ✅ User-defined functions
print_r($functions['internal']); // ✅ Internal functions
?>

Step 5: Verify Include Path

<?php
// ✅ Check if the include path is correct
if (file_exists('path/to/functions.php')) {
    require_once 'path/to/functions.php';
} else {
    die('Function file not found');
}
?>

Step 6: Check for Syntax Errors

<?php
// ✅ Run PHP lint to check for syntax errors
// php -l functions.php
?>

---

Common Mistakes to Avoid

1. Calling Function Before Definition

<?php
// ❌ Wrong - calling before definition
echo my_function(); // ❌ Fatal error

function my_function() {
    return "Hello";
}
?>

2. Incorrect File Paths

<?php
// ❌ Wrong - incorrect path
require_once 'functions/helpers.php'; // ❌ File doesn't exist at this path

// ✅ Correct
require_once __DIR__ . '/functions/helpers.php';
?>

3. Not Using Autoloader Properly

<?php
// ❌ Forgetting to include Composer autoloader
// require_once 'vendor/autoload.php'; // ❌ Commented out
?>

4. Function Name Conflicts

<?php
// ❌ Defining function with same name as internal PHP function
function array_push() { // ❌ This will cause an error
    // ...
}
?>

5. Case Sensitivity Issues

<?php
// ❌ PHP function names are case-insensitive, but be consistent
function myFunction() { }
// Both of these work, but be consistent:
myFunction(); // ✅
myfunction(); // ✅ Works but not recommended
?>

---

Performance Considerations

1. Minimize File Inclusions

<?php
// ✅ Only include files you actually need
require_once 'essential_functions.php';
// ❌ Don't include everything just in case
// require_once 'all_functions.php';
?>

2. Use Autoloader Efficiently

<?php
// ✅ Organize functions in classes when possible
// This allows for lazy loading
class Helper {
    public static function myFunction() {
        // ✅ Only loaded when needed
    }
}
?>

3. Cache Function Lookups

<?php
// ✅ For frequently called functions, consider caching
static $functionExists = null;
if ($functionExists === null) {
    $functionExists = function_exists('my_function');
}

if ($functionExists) {
    my_function();
}
?>

---

Security Considerations

1. Validate Function Names

<?php
// ✅ Don't allow user input to determine function names
$userInput = $_GET['function'] ?? '';
// ❌ Never do this:
// call_user_func($userInput);

// ✅ Instead, validate against a whitelist
$allowedFunctions = ['function1', 'function2', 'function3'];
if (in_array($userInput, $allowedFunctions) && function_exists($userInput)) {
    call_user_func($userInput);
}
?>

2. Sanitize Function Parameters

<?php
// ✅ Always sanitize parameters passed to functions
$userInput = sanitize_input($_POST['data'] ?? '');
$result = process_data($userInput);
?>

3. Use Namespaces

<?php
// ✅ Use namespaces to avoid conflicts
namespace MyApp\Helpers;

function my_function() {
    // ✅ Protected from global namespace conflicts
}
?>

---

Testing Function Scenarios

1. Test Function Existence

<?php
public function testFunctionExists()
{
    $this->assertTrue(function_exists('my_function'));
}
?>

2. Test Function Behavior

<?php
public function testFunctionBehavior()
{
    $result = my_function('test');
    $this->assertEquals('expected_result', $result);
}
?>

3. Test Error Handling

<?php
public function testUndefinedFunctionError()
{
    $this->expectException(Error::class);
    non_existent_function();
}
?>

4. Test Conditional Functions

<?php
public function testConditionalFunctionDefinition()
{
    // ✅ Test that conditional function is defined
    $this->assertTrue(function_exists('array_is_list'));
}
?>

---

Alternative Solutions

1. Use Classes Instead of Functions

<?php
// ✅ Use classes for better organization
class Helper {
    public static function formatName($first, $last) {
        return ucfirst($first) . ' ' . ucfirst($last);
    }
}
?>

2. Implement Magic Methods

<?php
class FunctionHandler {
    private $functions = [];
    
    public function __call($name, $arguments) {
        if (isset($this->functions[$name])) {
            return call_user_func_array($this->functions[$name], $arguments);
        }
        throw new BadMethodCallException("Function {$name} does not exist");
    }
}
?>

3. Use Dependency Injection

<?php
class MyService {
    private $helper;
    
    public function __construct($helper) {
        $this->helper = $helper;
    }
    
    public function doSomething() {
        return $this->helper->formatName('John', 'Doe');
    }
}
?>

---

Migration Checklist

• Verify all required files are included/autoloaded
• Check function names for typos
• Ensure functions are defined before use
• Validate file paths in include/require statements
• Test all function calls in the application
• Set up proper error handling
• Configure autoloader if using Composer
• Document function dependencies
• Implement function existence checks where needed
• Test in different PHP versions if using polyfills

---

Conclusion

The ‘Fatal error: Uncaught Error: Call to undefined function’ error is a common but preventable PHP issue that occurs when functions are not properly defined or included. By following the solutions provided in this guide—implementing proper function declaration, using autoloading, managing namespaces, and following best practices—you can effectively prevent and resolve this error in your PHP applications.

The key is to understand PHP’s function loading mechanisms, implement proper inclusion patterns, use modern PHP features like Composer autoloading, and maintain clean, well-organized code. With proper function management, your PHP applications will execute reliably and avoid common runtime errors.

Remember to test your changes thoroughly, follow PHP best practices for function management, implement proper error handling, and regularly review your function inclusion patterns to ensure your applications maintain the best possible architecture and avoid common undefined function errors.