File: ...\backend\src\Http\Controllers\UserController.php:30

20:            view()->share([
21:                'roles' => $roleRepository->all(),
22:            ]);
23:        }
24:
25:        public function profile(Request $request, Guard $guard)
26:        {
27:            $id = $guard->id();
28:
29:            echo $this->edit($request, $id);
30:            a;
31:        }
32:    }
33:    

1. ...\backend\src\Http\Controllers\UserController.php:30 source  Illuminate\Foundation\Bootstrap\HandleExceptions->handleError(arguments)

   20:            view()->share([
   21:                'roles' => $roleRepository->all(),
   22:            ]);
   23:        }
   24:
   25:        public function profile(Request $request, Guard $guard)
   26:        {
   27:            $id = $guard->id();
   28:
   29:            echo $this->edit($request, $id);
   30:            a;
   31:        }
   32:    }
   33:    
   

   $level	8
   $message	"Use of undefined constant a - assumed 'a'" (41)
   $file	"C:\Users\recca\UniServerZ\www\asf\_laravel\vendor\recca0120\backend\src\Http\Controllers\UserController.php" (107)
   $line	30
   $context

2. inner-code Recca0120\Backend\Http\Controllers\UserController->profile(arguments)

   $request
   $guard

3. ...\framework\src\Illuminate\Routing\Controller.php:76 source  call_user_func_array(arguments)

   66:
   67:        /**
   68:         * Execute an action on the controller.
   69:         *
   70:         * @param  string  $method
   71:         * @param  array   $parameters
   72:         * @return \Symfony\Component\HttpFoundation\Response
   73:         */
   74:        public function callAction($method, $parameters)
   75:        {
   76:            return call_user_func_array([$this, $method], $parameters);
   77:        }
   78:
   79:        /**
   80:         * Handle calls to missing methods on the controller.
   

   $function_name
   $parameters

4. ...\src\Illuminate\Routing\ControllerDispatcher.php:146 source  Illuminate\Routing\Controller->callAction(arguments)

   136:         * @param  \Illuminate\Routing\Route  $route
   137:         * @param  string  $method
   138:         * @return mixed
   139:         */
   140:        protected function call($instance, $route, $method)
   141:        {
   142:            $parameters = $this->resolveClassMethodDependencies(
   143:                $route->parametersWithoutNulls(), $instance, $method
   144:            );
   145:
   146:            return $instance->callAction($method, $parameters);
   147:        }
   148:    }
   149:    
   

   $method	"profile" (7)
   $parameters

5. ...\src\Illuminate\Routing\ControllerDispatcher.php:94 source  Illuminate\Routing\ControllerDispatcher->call(arguments)

   84:            $middleware = $shouldSkipMiddleware ? [] : $this->getMiddleware($instance, $method);
   85:
   86:            // Here we will make a stack onion instance to execute this request in, which gives
   87:            // us the ability to define middlewares on controllers. We will return the given
   88:            // response back out so that "after" filters can be run after the middlewares.
   89:            return (new Pipeline($this->container))
   90:                        ->send($request)
   91:                        ->through($middleware)
   92:                        ->then(function ($request) use ($instance, $route, $method) {
   93:                            return $this->router->prepareResponse(
   94:                                $request, $this->call($instance, $route, $method)
   95:                            );
   96:                        });
   97:        }
   98:
   

   $instance
   $route
   $method	"profile" (7)

6. inner-code Illuminate\Routing\ControllerDispatcher->Illuminate\Routing\{closure}(arguments)

   #0

7. ...\framework\src\Illuminate\Routing\Pipeline.php:52 source  call_user_func(arguments)

   42:        /**
   43:         * Get the initial slice to begin the stack call.
   44:         *
   45:         * @param  \Closure  $destination
   46:         * @return \Closure
   47:         */
   48:        protected function getInitialSlice(Closure $destination)
   49:        {
   50:            return function ($passable) use ($destination) {
   51:                try {
   52:                    return call_user_func($destination, $passable);
   53:                } catch (Exception $e) {
   54:                    return $this->handleException($passable, $e);
   55:                } catch (Throwable $e) {
   56:                    return $this->handleException($passable, new FatalThrowableError($e));
   

   $function_name
   $parameters

8. inner-code Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

   #0

9. ...\framework\src\Illuminate\Pipeline\Pipeline.php:103 source  call_user_func(arguments)

    93:         * @return mixed
    94:         */
    95:        public function then(Closure $destination)
    96:        {
    97:            $firstSlice = $this->getInitialSlice($destination);
    98:
    99:            $pipes = array_reverse($this->pipes);
   100:
   101:            return call_user_func(
   102:                array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
   103:            );
   104:        }
   105:
   106:        /**
   107:         * Get a Closure that represents a slice of the application onion.
   

   $function_name
   $parameters

10. ...\src\Illuminate\Routing\ControllerDispatcher.php:96 source  Illuminate\Pipeline\Pipeline->then(arguments)

     86:            // Here we will make a stack onion instance to execute this request in, which gives
     87:            // us the ability to define middlewares on controllers. We will return the given
     88:            // response back out so that "after" filters can be run after the middlewares.
     89:            return (new Pipeline($this->container))
     90:                        ->send($request)
     91:                        ->through($middleware)
     92:                        ->then(function ($request) use ($instance, $route, $method) {
     93:                            return $this->router->prepareResponse(
     94:                                $request, $this->call($instance, $route, $method)
     95:                            );
     96:                        });
     97:        }
     98:
     99:        /**
    100:         * Get the middleware for the controller instance.
    

    $destination

11. ...\src\Illuminate\Routing\ControllerDispatcher.php:54 source  Illuminate\Routing\ControllerDispatcher->callWithinStack(arguments)

    44:         * @param  \Illuminate\Routing\Route  $route
    45:         * @param  \Illuminate\Http\Request  $request
    46:         * @param  string  $controller
    47:         * @param  string  $method
    48:         * @return mixed
    49:         */
    50:        public function dispatch(Route $route, Request $request, $controller, $method)
    51:        {
    52:            $instance = $this->makeController($controller);
    53:
    54:            return $this->callWithinStack($instance, $route, $request, $method);
    55:        }
    56:
    57:        /**
    58:         * Make a controller instance via the IoC container.
    

    $instance
    $route
    $request
    $method	"profile" (7)

12. ...\laravel\framework\src\Illuminate\Routing\Route.php:174 source  Illuminate\Routing\ControllerDispatcher->dispatch(arguments)

    164:         * @param  \Illuminate\Http\Request  $request
    165:         * @return mixed
    166:         *
    167:         * @throws \Symfony\Component\HttpKernel\Exception\NotFoundHttpException
    168:         */
    169:        protected function runController(Request $request)
    170:        {
    171:            list($class, $method) = explode('@', $this->action['uses']);
    172:
    173:            return (new ControllerDispatcher($this->router, $this->container))
    174:                        ->dispatch($this, $request, $class, $method);
    175:        }
    176:
    177:        /**
    178:         * Determine if the route matches given request.
    

    $route
    $request
    $controller	"Recca0120\Backend\Http\Controllers\UserController" (49)
    $method	"profile" (7)

13. ...\laravel\framework\src\Illuminate\Routing\Route.php:140 source  Illuminate\Routing\Route->runController(arguments)

    130:         */
    131:        public function run(Request $request)
    132:        {
    133:            $this->container = $this->container ?: new Container;
    134:
    135:            try {
    136:                if (! is_string($this->action['uses'])) {
    137:                    return $this->runCallable($request);
    138:                }
    139:
    140:                return $this->runController($request);
    141:            } catch (HttpResponseException $e) {
    142:                return $e->getResponse();
    143:            }
    144:        }
    

    $request

14. ...\framework\src\Illuminate\Routing\Router.php:703 source  Illuminate\Routing\Route->run(arguments)

    693:                                    $this->container->make('middleware.disable') === true;
    694:
    695:            $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddlewares($route);
    696:
    697:            return (new Pipeline($this->container))
    698:                            ->send($request)
    699:                            ->through($middleware)
    700:                            ->then(function ($request) use ($route) {
    701:                                return $this->prepareResponse(
    702:                                    $request,
    703:                                    $route->run($request)
    704:                                );
    705:                            });
    706:        }
    707:
    

    $request

15. inner-code Illuminate\Routing\Router->Illuminate\Routing\{closure}(arguments)

    #0

16. ...\framework\src\Illuminate\Routing\Pipeline.php:52 source  call_user_func(arguments)

    42:        /**
    43:         * Get the initial slice to begin the stack call.
    44:         *
    45:         * @param  \Closure  $destination
    46:         * @return \Closure
    47:         */
    48:        protected function getInitialSlice(Closure $destination)
    49:        {
    50:            return function ($passable) use ($destination) {
    51:                try {
    52:                    return call_user_func($destination, $passable);
    53:                } catch (Exception $e) {
    54:                    return $this->handleException($passable, $e);
    55:                } catch (Throwable $e) {
    56:                    return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

17. ...\backend\src\Http\Middleware\Authenticate.php:44 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    34:            //     $user->isSuperAdmin() === false
    35:            // ) {
    36:            if ($this->checkRoute($user, $route) === false) {
    37:                if ($request->ajax()) {
    38:                    return response('Unauthorized.', 401);
    39:                } else {
    40:                    return abort(401);
    41:                }
    42:            }
    43:
    44:            return $next($request);
    45:        }
    46:
    47:        public function checkRoute($user, Route $route)
    48:        {
    

    #0

18. inner-code Recca0120\Backend\Http\Middleware\Authenticate->handle(arguments)

    $request
    $next

19. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

20. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

21. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

22. ...\Foundation\Http\Middleware\VerifyCsrfToken.php:64 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    54:         * @throws \Illuminate\Session\TokenMismatchException
    55:         */
    56:        public function handle($request, Closure $next)
    57:        {
    58:            if (
    59:                $this->isReading($request) ||
    60:                $this->runningUnitTests() ||
    61:                $this->shouldPassThrough($request) ||
    62:                $this->tokensMatch($request)
    63:            ) {
    64:                return $this->addCookieToResponse($request, $next($request));
    65:            }
    66:
    67:            throw new TokenMismatchException;
    68:        }
    

    #0

23. inner-code Illuminate\Foundation\Http\Middleware\VerifyCsrfToken->handle(arguments)

    $request
    $next

24. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

25. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

26. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

27. ...\View\Middleware\ShareErrorsFromSession.php:49 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    39:            // its value with all view instances so the views can easily access errors
    40:            // without having to bind. An empty bag is set when there aren't errors.
    41:            $this->view->share(
    42:                'errors', $request->session()->get('errors') ?: new ViewErrorBag
    43:            );
    44:
    45:            // Putting the errors in the view for every view allows the developer to just
    46:            // assume that some errors are always available, which is convenient since
    47:            // they don't have to continually run checks for the presence of errors.
    48:
    49:            return $next($request);
    50:        }
    51:    }
    52:    
    

    #0

28. inner-code Illuminate\View\Middleware\ShareErrorsFromSession->handle(arguments)

    $request
    $next

29. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

30. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

31. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

32. ...\src\Illuminate\Session\Middleware\StartSession.php:62 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    52:
    53:            // If a session driver has been configured, we will need to start the session here
    54:            // so that the data is ready for an application. Note that the Laravel sessions
    55:            // do not make use of PHP "native" sessions in any way since they are crappy.
    56:            if ($this->sessionConfigured()) {
    57:                $session = $this->startSession($request);
    58:
    59:                $request->setSession($session);
    60:            }
    61:
    62:            $response = $next($request);
    63:
    64:            // Again, if the session has been configured we will need to close out the session
    65:            // so that the attributes may be persisted to some storage medium. We will also
    66:            // add the session identifier cookie to the application response headers now.
    

    #0

33. inner-code Illuminate\Session\Middleware\StartSession->handle(arguments)

    $request
    $next

34. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

35. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

36. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

37. ...\Cookie\Middleware\AddQueuedCookiesToResponse.php:37 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    27:
    28:        /**
    29:         * Handle an incoming request.
    30:         *
    31:         * @param  \Illuminate\Http\Request  $request
    32:         * @param  \Closure  $next
    33:         * @return mixed
    34:         */
    35:        public function handle($request, Closure $next)
    36:        {
    37:            $response = $next($request);
    38:
    39:            foreach ($this->cookies->getQueuedCookies() as $cookie) {
    40:                $response->headers->setCookie($cookie);
    41:            }
    

    #0

38. inner-code Illuminate\Cookie\Middleware\AddQueuedCookiesToResponse->handle(arguments)

    $request
    $next

39. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

40. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

41. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

42. ...\Illuminate\Cookie\Middleware\EncryptCookies.php:59 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    49:
    50:        /**
    51:         * Handle an incoming request.
    52:         *
    53:         * @param  \Illuminate\Http\Request  $request
    54:         * @param  \Closure  $next
    55:         * @return mixed
    56:         */
    57:        public function handle($request, Closure $next)
    58:        {
    59:            return $this->encrypt($next($this->decrypt($request)));
    60:        }
    61:
    62:        /**
    63:         * Decrypt the cookies on the request.
    

    #0

43. inner-code Illuminate\Cookie\Middleware\EncryptCookies->handle(arguments)

    $request
    $next

44. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

45. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

46. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

47. inner-code Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    #0

48. ...\framework\src\Illuminate\Pipeline\Pipeline.php:103 source  call_user_func(arguments)

     93:         * @return mixed
     94:         */
     95:        public function then(Closure $destination)
     96:        {
     97:            $firstSlice = $this->getInitialSlice($destination);
     98:
     99:            $pipes = array_reverse($this->pipes);
    100:
    101:            return call_user_func(
    102:                array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
    103:            );
    104:        }
    105:
    106:        /**
    107:         * Get a Closure that represents a slice of the application onion.
    

    $function_name
    $parameters

49. ...\framework\src\Illuminate\Routing\Router.php:705 source  Illuminate\Pipeline\Pipeline->then(arguments)

    695:            $middleware = $shouldSkipMiddleware ? [] : $this->gatherRouteMiddlewares($route);
    696:
    697:            return (new Pipeline($this->container))
    698:                            ->send($request)
    699:                            ->through($middleware)
    700:                            ->then(function ($request) use ($route) {
    701:                                return $this->prepareResponse(
    702:                                    $request,
    703:                                    $route->run($request)
    704:                                );
    705:                            });
    706:        }
    707:
    708:        /**
    709:         * Gather the middleware for the given route.
    

    $destination

50. ...\framework\src\Illuminate\Routing\Router.php:678 source  Illuminate\Routing\Router->runRouteWithinStack(arguments)

    668:            // route resolver on the request so middlewares assigned to the route will
    669:            // receive access to this route instance for checking of the parameters.
    670:            $route = $this->findRoute($request);
    671:
    672:            $request->setRouteResolver(function () use ($route) {
    673:                return $route;
    674:            });
    675:
    676:            $this->events->fire(new Events\RouteMatched($route, $request));
    677:
    678:            $response = $this->runRouteWithinStack($route, $request);
    679:
    680:            return $this->prepareResponse($request, $response);
    681:        }
    682:
    

    $route
    $request

51. ...\framework\src\Illuminate\Routing\Router.php:654 source  Illuminate\Routing\Router->dispatchToRoute(arguments)

    644:        /**
    645:         * Dispatch the request to the application.
    646:         *
    647:         * @param  \Illuminate\Http\Request  $request
    648:         * @return \Illuminate\Http\Response
    649:         */
    650:        public function dispatch(Request $request)
    651:        {
    652:            $this->currentRequest = $request;
    653:
    654:            $response = $this->dispatchToRoute($request);
    655:
    656:            return $this->prepareResponse($request, $response);
    657:        }
    658:
    

    $request

52. ...\src\Illuminate\Foundation\Http\Kernel.php:246 source  Illuminate\Routing\Router->dispatch(arguments)

    236:        /**
    237:         * Get the route dispatcher callback.
    238:         *
    239:         * @return \Closure
    240:         */
    241:        protected function dispatchToRouter()
    242:        {
    243:            return function ($request) {
    244:                $this->app->instance('request', $request);
    245:
    246:                return $this->router->dispatch($request);
    247:            };
    248:        }
    249:
    250:        /**
    

    $request

53. inner-code Illuminate\Foundation\Http\Kernel->Illuminate\Foundation\Http\{closure}(arguments)

    #0

54. ...\framework\src\Illuminate\Routing\Pipeline.php:52 source  call_user_func(arguments)

    42:        /**
    43:         * Get the initial slice to begin the stack call.
    44:         *
    45:         * @param  \Closure  $destination
    46:         * @return \Closure
    47:         */
    48:        protected function getInitialSlice(Closure $destination)
    49:        {
    50:            return function ($passable) use ($destination) {
    51:                try {
    52:                    return call_user_func($destination, $passable);
    53:                } catch (Exception $e) {
    54:                    return $this->handleException($passable, $e);
    55:                } catch (Throwable $e) {
    56:                    return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

55. ...\laravel-pjax\src\Middleware\FilterIfPjax.php:29 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    19:        /**
    20:         * Handle an incoming request.
    21:         *
    22:         * @param \Illuminate\Http\Request $request
    23:         * @param \Closure                 $next
    24:         *
    25:         * @return mixed
    26:         */
    27:        public function handle(Request $request, Closure $next)
    28:        {
    29:            $response = $next($request);
    30:
    31:            if (!$request->pjax() || $response->isRedirection()) {
    32:                return $response;
    33:            }
    

    #0

56. inner-code Spatie\Pjax\Middleware\FilterIfPjax->handle(arguments)

    $request
    $next

57. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

58. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

59. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

60. ...\Http\Middleware\CheckForMaintenanceMode.php:44 source  Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    34:         * @return mixed
    35:         *
    36:         * @throws \Symfony\Component\HttpKernel\Exception\HttpException
    37:         */
    38:        public function handle($request, Closure $next)
    39:        {
    40:            if ($this->app->isDownForMaintenance()) {
    41:                throw new HttpException(503);
    42:            }
    43:
    44:            return $next($request);
    45:        }
    46:    }
    47:    
    

    #0

61. inner-code Illuminate\Foundation\Http\Middleware\CheckForMaintenanceMode->handle(arguments)

    $request
    $next

62. ...\framework\src\Illuminate\Pipeline\Pipeline.php:124 source  call_user_func_array(arguments)

    114:                return function ($passable) use ($stack, $pipe) {
    115:                    // If the pipe is an instance of a Closure, we will just call it directly but
    116:                    // otherwise we'll resolve the pipes out of the container and call it with
    117:                    // the appropriate method and arguments, returning the results back out.
    118:                    if ($pipe instanceof Closure) {
    119:                        return call_user_func($pipe, $passable, $stack);
    120:                    } else {
    121:                        list($name, $parameters) = $this->parsePipeString($pipe);
    122:
    123:                        return call_user_func_array([$this->container->make($name), $this->method],
    124:                                array_merge([$passable, $stack], $parameters));
    125:                    }
    126:                };
    127:            };
    128:        }
    

    $function_name
    $parameters

63. inner-code Illuminate\Pipeline\Pipeline->Illuminate\Pipeline\{closure}(arguments)

    #0

64. ...\framework\src\Illuminate\Routing\Pipeline.php:32 source  call_user_func(arguments)

    22:         *
    23:         * @return \Closure
    24:         */
    25:        protected function getSlice()
    26:        {
    27:            return function ($stack, $pipe) {
    28:                return function ($passable) use ($stack, $pipe) {
    29:                    try {
    30:                        $slice = parent::getSlice();
    31:
    32:                        return call_user_func($slice($stack, $pipe), $passable);
    33:                    } catch (Exception $e) {
    34:                        return $this->handleException($passable, $e);
    35:                    } catch (Throwable $e) {
    36:                        return $this->handleException($passable, new FatalThrowableError($e));
    

    $function_name
    $parameters

65. inner-code Illuminate\Routing\Pipeline->Illuminate\Routing\{closure}(arguments)

    #0

66. ...\framework\src\Illuminate\Pipeline\Pipeline.php:103 source  call_user_func(arguments)

     93:         * @return mixed
     94:         */
     95:        public function then(Closure $destination)
     96:        {
     97:            $firstSlice = $this->getInitialSlice($destination);
     98:
     99:            $pipes = array_reverse($this->pipes);
    100:
    101:            return call_user_func(
    102:                array_reduce($pipes, $this->getSlice(), $firstSlice), $this->passable
    103:            );
    104:        }
    105:
    106:        /**
    107:         * Get a Closure that represents a slice of the application onion.
    

    $function_name
    $parameters

67. ...\src\Illuminate\Foundation\Http\Kernel.php:132 source  Illuminate\Pipeline\Pipeline->then(arguments)

    122:        {
    123:            $this->app->instance('request', $request);
    124:
    125:            Facade::clearResolvedInstance('request');
    126:
    127:            $this->bootstrap();
    128:
    129:            return (new Pipeline($this->app))
    130:                        ->send($request)
    131:                        ->through($this->app->shouldSkipMiddleware() ? [] : $this->middleware)
    132:                        ->then($this->dispatchToRouter());
    133:        }
    134:
    135:        /**
    136:         * Call the terminate method on any terminable middleware.
    

    $destination

68. ...\src\Illuminate\Foundation\Http\Kernel.php:99 source  Illuminate\Foundation\Http\Kernel->sendRequestThroughRouter(arguments)

     89:         * Handle an incoming HTTP request.
     90:         *
     91:         * @param  \Illuminate\Http\Request  $request
     92:         * @return \Illuminate\Http\Response
     93:         */
     94:        public function handle($request)
     95:        {
     96:            try {
     97:                $request->enableHttpMethodParameterOverride();
     98:
     99:                $response = $this->sendRequestThroughRouter($request);
    100:            } catch (Exception $e) {
    101:                $this->reportException($e);
    102:
    103:                $response = $this->renderException($request, $e);
    

    $request

69. C:\Users\recca\UniServerZ\www\asf\index.php:53 source  Illuminate\Foundation\Http\Kernel->handle(arguments)

    43:    | through the kernel, and send the associated response back to
    44:    | the client's browser allowing them to enjoy the creative
    45:    | and wonderful application we have prepared for them.
    46:    |
    47:    */
    48:
    49:    $kernel = $app->make(Illuminate\Contracts\Http\Kernel::class);
    50:
    51:    $response = $kernel->handle(
    52:        $request = Illuminate\Http\Request::capture()
    53:    );
    54:
    55:    $response->send();
    56:
    57:    $kernel->terminate($request, $response);
    

    $request