!C99Shell v. 2.0 [PHP 7 Update] [25.02.2019]!

Software: Apache. PHP/7.3.33 

uname -a: Linux acloudg.aryanict.com 4.18.0-513.9.1.lve.el8.x86_64 #1 SMP Mon Dec 4 15:01:22 UTC
2023 x86_64
 

uid=1095(katebhospital) gid=1098(katebhospital) groups=1098(katebhospital) 

Safe-mode: OFF (not secure)

/opt/alt/php54/usr/share/pear/Symfony/Component/Console/Command/   drwxr-xr-x
Free 293.64 GB of 429.69 GB (68.34%)
Home    Back    Forward    UPDIR    Refresh    Search    Buffer    Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Feedback    Self remove    Logout    


Viewing file:     Command.php (16.05 KB)      -rw-r--r--
Select action/file-type:
(+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) |
<?php

/*
 * This file is part of the Symfony package.
 *
 * (c) Fabien Potencier <fabien@symfony.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Symfony\Component\Console\Command;

use 
Symfony\Component\Console\Descriptor\TextDescriptor;
use 
Symfony\Component\Console\Descriptor\XmlDescriptor;
use 
Symfony\Component\Console\Input\InputDefinition;
use 
Symfony\Component\Console\Input\InputOption;
use 
Symfony\Component\Console\Input\InputArgument;
use 
Symfony\Component\Console\Input\InputInterface;
use 
Symfony\Component\Console\Output\BufferedOutput;
use 
Symfony\Component\Console\Output\OutputInterface;
use 
Symfony\Component\Console\Application;
use 
Symfony\Component\Console\Helper\HelperSet;

/**
 * Base class for all commands.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 *
 * @api
 */
class Command
{
    private 
$application;
    private 
$name;
    private 
$aliases = array();
    private 
$definition;
    private 
$help;
    private 
$description;
    private 
$ignoreValidationErrors false;
    private 
$applicationDefinitionMerged false;
    private 
$applicationDefinitionMergedWithArgs false;
    private 
$code;
    private 
$synopsis;
    private 
$helperSet;

    
/**
     * Constructor.
     *
     * @param string|null $name The name of the command; passing null means it must be set in configure()
     *
     * @throws \LogicException When the command name is empty
     *
     * @api
     */
    
public function __construct($name null)
    {
        
$this->definition = new InputDefinition();

        if (
null !== $name) {
            
$this->setName($name);
        }

        
$this->configure();

        if (!
$this->name) {
            throw new \
LogicException('The command name cannot be empty.');
        }
    }

    
/**
     * Ignores validation errors.
     *
     * This is mainly useful for the help command.
     */
    
public function ignoreValidationErrors()
    {
        
$this->ignoreValidationErrors true;
    }

    
/**
     * Sets the application instance for this command.
     *
     * @param Application $application An Application instance
     *
     * @api
     */
    
public function setApplication(Application $application null)
    {
        
$this->application $application;
        if (
$application) {
            
$this->setHelperSet($application->getHelperSet());
        } else {
            
$this->helperSet null;
        }
    }

    
/**
     * Sets the helper set.
     *
     * @param HelperSet $helperSet A HelperSet instance
     */
    
public function setHelperSet(HelperSet $helperSet)
    {
        
$this->helperSet $helperSet;
    }

    
/**
     * Gets the helper set.
     *
     * @return HelperSet A HelperSet instance
     */
    
public function getHelperSet()
    {
        return 
$this->helperSet;
    }

    
/**
     * Gets the application instance for this command.
     *
     * @return Application An Application instance
     *
     * @api
     */
    
public function getApplication()
    {
        return 
$this->application;
    }

    
/**
     * Checks whether the command is enabled or not in the current environment
     *
     * Override this to check for x or y and return false if the command can not
     * run properly under the current conditions.
     *
     * @return Boolean
     */
    
public function isEnabled()
    {
        return 
true;
    }

    
/**
     * Configures the current command.
     */
    
protected function configure()
    {
    }

    
/**
     * Executes the current command.
     *
     * This method is not abstract because you can use this class
     * as a concrete class. In this case, instead of defining the
     * execute() method, you set the code to execute by passing
     * a Closure to the setCode() method.
     *
     * @param InputInterface  $input  An InputInterface instance
     * @param OutputInterface $output An OutputInterface instance
     *
     * @return null|integer null or 0 if everything went fine, or an error code
     *
     * @throws \LogicException When this abstract method is not implemented
     * @see    setCode()
     */
    
protected function execute(InputInterface $inputOutputInterface $output)
    {
        throw new \
LogicException('You must override the execute() method in the concrete command class.');
    }

    
/**
     * Interacts with the user.
     *
     * @param InputInterface  $input  An InputInterface instance
     * @param OutputInterface $output An OutputInterface instance
     */
    
protected function interact(InputInterface $inputOutputInterface $output)
    {
    }

    
/**
     * Initializes the command just after the input has been validated.
     *
     * This is mainly useful when a lot of commands extends one main command
     * where some things need to be initialized based on the input arguments and options.
     *
     * @param InputInterface  $input  An InputInterface instance
     * @param OutputInterface $output An OutputInterface instance
     */
    
protected function initialize(InputInterface $inputOutputInterface $output)
    {
    }

    
/**
     * Runs the command.
     *
     * The code to execute is either defined directly with the
     * setCode() method or by overriding the execute() method
     * in a sub-class.
     *
     * @param InputInterface  $input  An InputInterface instance
     * @param OutputInterface $output An OutputInterface instance
     *
     * @return integer The command exit code
     *
     * @throws \Exception
     *
     * @see setCode()
     * @see execute()
     *
     * @api
     */
    
public function run(InputInterface $inputOutputInterface $output)
    {
        
// force the creation of the synopsis before the merge with the app definition
        
$this->getSynopsis();

        
// add the application arguments and options
        
$this->mergeApplicationDefinition();

        
// bind the input against the command specific arguments/options
        
try {
            
$input->bind($this->definition);
        } catch (\
Exception $e) {
            if (!
$this->ignoreValidationErrors) {
                throw 
$e;
            }
        }

        
$this->initialize($input$output);

        if (
$input->isInteractive()) {
            
$this->interact($input$output);
        }

        
$input->validate();

        if (
$this->code) {
            
$statusCode call_user_func($this->code$input$output);
        } else {
            
$statusCode $this->execute($input$output);
        }

        return 
is_numeric($statusCode) ? (int) $statusCode 0;
    }

    
/**
     * Sets the code to execute when running this command.
     *
     * If this method is used, it overrides the code defined
     * in the execute() method.
     *
     * @param callable $code A callable(InputInterface $input, OutputInterface $output)
     *
     * @return Command The current instance
     *
     * @throws \InvalidArgumentException
     *
     * @see execute()
     *
     * @api
     */
    
public function setCode($code)
    {
        if (!
is_callable($code)) {
            throw new \
InvalidArgumentException('Invalid callable provided to Command::setCode.');
        }

        
$this->code $code;

        return 
$this;
    }

    
/**
     * Merges the application definition with the command definition.
     *
     * This method is not part of public API and should not be used directly.
     *
     * @param Boolean $mergeArgs Whether to merge or not the Application definition arguments to Command definition arguments
     */
    
public function mergeApplicationDefinition($mergeArgs true)
    {
        if (
null === $this->application || (true === $this->applicationDefinitionMerged && ($this->applicationDefinitionMergedWithArgs || !$mergeArgs))) {
            return;
        }

        if (
$mergeArgs) {
            
$currentArguments $this->definition->getArguments();
            
$this->definition->setArguments($this->application->getDefinition()->getArguments());
            
$this->definition->addArguments($currentArguments);
        }

        
$this->definition->addOptions($this->application->getDefinition()->getOptions());

        
$this->applicationDefinitionMerged true;
        if (
$mergeArgs) {
            
$this->applicationDefinitionMergedWithArgs true;
        }
    }

    
/**
     * Sets an array of argument and option instances.
     *
     * @param array|InputDefinition $definition An array of argument and option instances or a definition instance
     *
     * @return Command The current instance
     *
     * @api
     */
    
public function setDefinition($definition)
    {
        if (
$definition instanceof InputDefinition) {
            
$this->definition $definition;
        } else {
            
$this->definition->setDefinition($definition);
        }

        
$this->applicationDefinitionMerged false;

        return 
$this;
    }

    
/**
     * Gets the InputDefinition attached to this Command.
     *
     * @return InputDefinition An InputDefinition instance
     *
     * @api
     */
    
public function getDefinition()
    {
        return 
$this->definition;
    }

    
/**
     * Gets the InputDefinition to be used to create XML and Text representations of this Command.
     *
     * Can be overridden to provide the original command representation when it would otherwise
     * be changed by merging with the application InputDefinition.
     *
     * This method is not part of public API and should not be used directly.
     *
     * @return InputDefinition An InputDefinition instance
     */
    
public function getNativeDefinition()
    {
        return 
$this->getDefinition();
    }

    
/**
     * Adds an argument.
     *
     * @param string  $name        The argument name
     * @param integer $mode        The argument mode: InputArgument::REQUIRED or InputArgument::OPTIONAL
     * @param string  $description A description text
     * @param mixed   $default     The default value (for InputArgument::OPTIONAL mode only)
     *
     * @return Command The current instance
     *
     * @api
     */
    
public function addArgument($name$mode null$description ''$default null)
    {
        
$this->definition->addArgument(new InputArgument($name$mode$description$default));

        return 
$this;
    }

    
/**
     * Adds an option.
     *
     * @param string  $name        The option name
     * @param string  $shortcut    The shortcut (can be null)
     * @param integer $mode        The option mode: One of the InputOption::VALUE_* constants
     * @param string  $description A description text
     * @param mixed   $default     The default value (must be null for InputOption::VALUE_REQUIRED or InputOption::VALUE_NONE)
     *
     * @return Command The current instance
     *
     * @api
     */
    
public function addOption($name$shortcut null$mode null$description ''$default null)
    {
        
$this->definition->addOption(new InputOption($name$shortcut$mode$description$default));

        return 
$this;
    }

    
/**
     * Sets the name of the command.
     *
     * This method can set both the namespace and the name if
     * you separate them by a colon (:)
     *
     *     $command->setName('foo:bar');
     *
     * @param string $name The command name
     *
     * @return Command The current instance
     *
     * @throws \InvalidArgumentException When the name is invalid
     *
     * @api
     */
    
public function setName($name)
    {
        
$this->validateName($name);

        
$this->name $name;

        return 
$this;
    }

    
/**
     * Returns the command name.
     *
     * @return string The command name
     *
     * @api
     */
    
public function getName()
    {
        return 
$this->name;
    }

    
/**
     * Sets the description for the command.
     *
     * @param string $description The description for the command
     *
     * @return Command The current instance
     *
     * @api
     */
    
public function setDescription($description)
    {
        
$this->description $description;

        return 
$this;
    }

    
/**
     * Returns the description for the command.
     *
     * @return string The description for the command
     *
     * @api
     */
    
public function getDescription()
    {
        return 
$this->description;
    }

    
/**
     * Sets the help for the command.
     *
     * @param string $help The help for the command
     *
     * @return Command The current instance
     *
     * @api
     */
    
public function setHelp($help)
    {
        
$this->help $help;

        return 
$this;
    }

    
/**
     * Returns the help for the command.
     *
     * @return string The help for the command
     *
     * @api
     */
    
public function getHelp()
    {
        return 
$this->help;
    }

    
/**
     * Returns the processed help for the command replacing the %command.name% and
     * %command.full_name% patterns with the real values dynamically.
     *
     * @return string  The processed help for the command
     */
    
public function getProcessedHelp()
    {
        
$name $this->name;

        
$placeholders = array(
            
'%command.name%',
            
'%command.full_name%'
        
);
        
$replacements = array(
            
$name,
            
$_SERVER['PHP_SELF'].' '.$name
        
);

        return 
str_replace($placeholders$replacements$this->getHelp());
    }

    
/**
     * Sets the aliases for the command.
     *
     * @param array $aliases An array of aliases for the command
     *
     * @return Command The current instance
     *
     * @throws \InvalidArgumentException When an alias is invalid
     *
     * @api
     */
    
public function setAliases($aliases)
    {
        foreach (
$aliases as $alias) {
            
$this->validateName($alias);
        }

        
$this->aliases $aliases;

        return 
$this;
    }

    
/**
     * Returns the aliases for the command.
     *
     * @return array An array of aliases for the command
     *
     * @api
     */
    
public function getAliases()
    {
        return 
$this->aliases;
    }

    
/**
     * Returns the synopsis for the command.
     *
     * @return string The synopsis
     */
    
public function getSynopsis()
    {
        if (
null === $this->synopsis) {
            
$this->synopsis trim(sprintf('%s %s'$this->name$this->definition->getSynopsis()));
        }

        return 
$this->synopsis;
    }

    
/**
     * Gets a helper instance by name.
     *
     * @param string $name The helper name
     *
     * @return mixed The helper value
     *
     * @throws \InvalidArgumentException if the helper is not defined
     *
     * @api
     */
    
public function getHelper($name)
    {
        return 
$this->helperSet->get($name);
    }

    
/**
     * Returns a text representation of the command.
     *
     * @return string A string representing the command
     *
     * @deprecated Deprecated since version 2.3, to be removed in 3.0.
     */
    
public function asText()
    {
        
$descriptor = new TextDescriptor();
        
$output = new BufferedOutput(BufferedOutput::VERBOSITY_NORMALtrue);
        
$descriptor->describe($output$this, array('raw_output' => true));

        return 
$output->fetch();
    }

    
/**
     * Returns an XML representation of the command.
     *
     * @param Boolean $asDom Whether to return a DOM or an XML string
     *
     * @return string|\DOMDocument An XML string representing the command
     *
     * @deprecated Deprecated since version 2.3, to be removed in 3.0.
     */
    
public function asXml($asDom false)
    {
        
$descriptor = new XmlDescriptor();

        if (
$asDom) {
            return 
$descriptor->getCommandDocument($this);
        }

        
$output = new BufferedOutput();
        
$descriptor->describe($output$this);

        return 
$output->fetch();
    }

    
/**
     * Validates a command name.
     *
     * It must be non-empty and parts can optionally be separated by ":".
     *
     * @param string $name
     *
     * @throws \InvalidArgumentException When the name is invalid
     */
    
private function validateName($name)
    {
        if (!
preg_match('/^[^\:]++(\:[^\:]++)*$/'$name)) {
            throw new \
InvalidArgumentException(sprintf('Command name "%s" is invalid.'$name));
        }
    }
}

:: Command execute ::

Enter:
 
Select:
 

:: Search ::
  - regexp 

:: Upload ::
 
[ Read-Only ]

:: Make Dir ::
 
[ Read-Only ]
:: Make File ::
 
[ Read-Only ]

:: Go Dir ::
 
:: Go File ::
 

--[ c99shell v. 2.0 [PHP 7 Update] [25.02.2019] maintained by KaizenLouie | C99Shell Github | Generation time: 0.1005 ]--