Replies the arguments of the program including the boot agent name.
{@inheritDoc}
973583
@Override
	@SuppressWarnings("checkstyle:variabledeclarationusagedistance")
	public final String getProgramArguments(ILaunchConfiguration configuration) throws CoreException {
		// The following line get the standard arguments
		final String standardProgramArguments = super.getProgramArguments(configuration);

		// Get the specific SRE arguments
		final ISREInstall sre = getSREInstallFor(configuration, this.configAccessor, cfg -> getJavaProject(cfg));
		assert sre != null;

		return getProgramArguments(configuration, sre, standardProgramArguments);
	}
564209
public function get_args($name){
    if ( $this->checked ){
      $cmd_name = str_replace('_', '-', $name);
      return isset($this->commands[$cmd_name], $this->commands[$cmd_name]['args']) ? $this->commands[$cmd_name]['args'] : [];
    }
  }
570182
public function getArgument($name)
    {
        if (!$this->hasArgument($name)) {
            throw new InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
        }

        $arguments = \is_int($name) ? array_values($this->arguments) : $this->arguments;

        return $arguments[$name];
    }
174434
protected function execute(InputInterface $input, Output\OutputInterface $output)
    {
        foreach ($this->getDefinition()->getArguments() as $arg) {
            if ($arg->getName() === 'command') {
                continue;
            }
            if ($input->getArgument($arg->getName())) {
                $this->getContainer()->set(explode('.', $this->nameToVar($arg->getName())), $input->getArgument($arg->getName()));
            }
        }

        foreach ($this->opts as $opt) {
            if ($value = $input->getOption($this->varToName($opt))) {
                $this->getContainer()->set(explode('.', $opt), $value);
            }
        }

        foreach ($this->flags as $name => $value) {
            $varName = explode('.', $name);
            $optName = $this->varToName($name);
            $this->getContainer()->set($varName, $value);

            if ($input->getOption('no-' . $optName) && $input->getOption($optName)) {
                throw new \InvalidArgumentException("Conflicting options --no-{$optName} and --{$optName} supplied. That confuses me.");
            }
            if ($input->getOption('no-' . $optName)) {
                $this->getContainer()->set($varName, false);
            } elseif ($input->getOption($optName)) {
                $this->getContainer()->set($varName, true);
            }
        }

        $callable = $this->getContainer()->get($this->getTaskReference());
        call_user_func($callable, $this->getContainer());
    }
389745
public function executecommandFromName(InputInterface $input, OutputInterface $output, $commandNames, array $arguments, array $options, Config $config, ConfigService $s)
    {
        $silent = false;

        if ('?' === $commandNames{0}) {
            $silent = true;
            $commandNames = substr($commandNames, 1);
        }

        $this->executeHooks($input, $output, ':before', $config, $s);

        foreach (explode('+', $commandNames) as $_commandNames) {
            $exceptions = [];
            foreach (explode('~', $_commandNames) as $commandName) {
                $commandName = strtolower($commandName);
                try {
                    $command = $this->getCommand($commandName, $config);

                    if (method_exists($command, 'setConfigService')) {
                        $command->setConfigService($s);
                    }

                    if (method_exists($command, 'setOutput')) {
                        $command->setOutput($output);
                    }

                    if (method_exists($command, 'setInput')) {
                        $command->setInput($input);
                    }

                    if (method_exists($command, 'setConfig')) {
                        $command->setConfig($config);
                    }

                    $this->executeHooks($input, $output, $commandName.':before', $config, $s);
                    if (method_exists($command, 'execute')) {
                        $command->execute($arguments, $options);
                    } elseif (method_exists($command, '__invoke')) {
                        $command($arguments, $options);
                    } else {
                        $this->executeHooks($input, $output, $commandName.':failure', $config, $s);
                        throw new \RuntimeException(sprintf("Command '%s' is not executable", $commandName), 43);
                    }
                    $this->executeHooks($input, $output, $commandName.':after', $config, $s);
                } catch (\Exception $e) {
                    $exceptions[] = ['command' => $commandName, 'exception' => $e];
                }
            }
            if (count($exceptions)) {
                if ($silent) {
                    return $this;
                }

                $this->executeHooks($input, $output, ':failure', $config, $s);

                throw $exceptions[0]['exception'];
            }
        }

        $this->executeHooks($input, $output, ':after', $config, $s);

        return $this;
    }
1156581
public function getArgument(InputInterface $input, $key): ?string
    {
        if ($input->hasArgument($key)) {
            return $input->getArgument($key);
        }
        if (isset($this->arguments[$key])) {
            return $this->arguments[$key];
        }

        return null;
    }
286129
protected function doExecute()
    {
        $name        = $this->io->getArgument(0) ?: exit("Please enter command name");
        $namespace   = $this->io->getArgument(1) ?: exit("Please enter command namespace");
        $description = $this->getOption('d') ?: $name;

        if (!$name || !$namespace) {
            throw new \InvalidArgumentException('Need name & namespace.');
        }

        // Regularize Namespace
        $namespace = str_replace(['/', '\\'], ' ', $namespace);

        $namespace = ucwords($namespace);

        $namespace = str_replace(' ', '\\', $namespace);

        $namespace = explode('\\', $namespace);

        if ($namespace[0] == 'Command') {
            array_shift($namespace);
        }

        $class = $namespace;

        $class = array_pop($class);

        $namespace = implode('\\', $namespace);

        $replace = [
            '{{NAME}}' => $name,
            '{{NAMESPACE}}' => $namespace,
            '{{CLASS}}' => $class,
            '{{DESCRIPTION}}' => $description,
        ];

        $content = strtr($this->template, $replace);

        $config = Ioc::getConfig();

        $file = $config->get('path.root') . '/src/' . $namespace . '/' . $class . 'Command.php';

        $file = str_replace(['/', '\\'], DIRECTORY_SEPARATOR, $file);

        if (!File::write($file, $content)) {
            $this->out()->out('Failure when writing file.');

            return false;
        }

        $this->out('File generated: ' . $file);

        return true;
    }
431653
public function compileBootableClasses(): void
    {
        // list app root's
        foreach ($this->appRoots as $app) {
            $app .= '/Apps/Controller/' . env_name;
            $files = File::listFiles($app, ['.php'], true);
            foreach ($files as $file) {
                // define full class name with namespace
                $class = 'Apps\Controller\\' . env_name . '\\' . Str::cleanExtension($file);
                // check if class exists (must be loaded over autoloader), boot method exist and this is controller instanceof
                if (class_exists($class) && method_exists($class, 'boot') && is_a($class, 'Ffcms\Core\Arch\Controller', true)) {
                    $this->objects[] = $class;
                }
            }
        }

        // list widget root's
        foreach ($this->widgetRoots as $widget) {
            $widget .= '/Widgets/' . env_name;
            // widgets are packed in directory, classname should be the same with root directory name
            $dirs = Directory::scan($widget, GLOB_ONLYDIR, true);
            if (!Any::isArray($dirs)) {
                continue;
            }

            foreach ($dirs as $instance) {
                $class = 'Widgets\\' . env_name . '\\' . $instance . '\\' . $instance;
                if (class_exists($class) && method_exists($class, 'boot') && is_a($class, 'Ffcms\Core\Arch\Widget', true)) {
                    $this->objects[] = $class;
                }
            }
        }
    }
585107
protected function getCoreArguments()
    {
        if ($this->coreArguments !== null) {
            return $this->coreArguments;
        }

        $argvWithoutConfig = [];
        if (isset($_SERVER['argv'])) {
            $argv = $_SERVER['argv'];

            for ($i = 0; $i < count($argv); $i++) {
                if (preg_match('/^(?:-([^c-]*)?c|--config(?:=|$))(.*)$/', $argv[$i], $match)) {
                    if (!empty($match[2])) { //same index
                        $this->preloadConfiguration($match[2]);
                    } elseif (isset($argv[$i + 1])) { //next index
                        $this->preloadConfiguration($argv[++$i]);
                    }
                    if (!empty($match[1])) {
                        $argvWithoutConfig[] = "-" . $match[1]; //rest commands
                    }
                    continue;
                }
                $argvWithoutConfig[] = $argv[$i];
            }
        }

        return $this->coreArguments = new ArgvInput($argvWithoutConfig);
    }
589370
public function loadBootstrap()
    {
        if (null !== ($file = $this->getBootstrapFile())) {
            if (false === file_exists($file)) {
                throw new InvalidArgumentException(
                    sprintf(
                        'The bootstrap path "%s" is not a file or does not exist.',
                        $file
                    )
                );
            }

            /** @noinspection PhpIncludeInspection */
            include $file;
        }
    }
1144604
protected function specifyParameters()
    {
        // We will loop through all of the arguments and options for the command and
        // set them all on the base command instance. This specifies what can get
        // passed into these commands as "parameters" to control the execution.
        foreach ($this->getArguments() as $arguments)
        {
            call_user_func_array(array($this, 'addArgument'), $arguments);
        }

        // Options (Daemon + Custom)
        $options = $this->daemon ? $this->getDaemonOptions() : [];
        $options = array_merge([], $options, $this->getOptions());
        foreach ($options as $op_item)
        {
            call_user_func_array(array($this, 'addOption'), $op_item);
        }
    }
239217
public function bootstrapAlertSuccessFunction(array $args = []) {
        return $this->bootstrapAlert(ArrayHelper::get($args, "content"), ArrayHelper::get($args, "dismissible"), "alert-" . BootstrapInterface::BOOTSTRAP_SUCCESS);
    }
625430
protected function specifyParameters()
	{
		// We will loop through all of the arguments and options for the command and
		// set them all on the base command instance. This specifies what can get
		// passed into these commands as "parameters" to control the execution.
		foreach ($this->getArguments() as $arguments)
		{
			call_user_func_array(array($this, 'addArgument'), $arguments);
		}

		foreach ($this->getOptions() as $options)
		{
			call_user_func_array(array($this, 'addOption'), $options);
		}
	}
1068972
public function arguments()
    {
        
        if ($this->optind < $this->argc) {
            for ($i = $this->optind; $i < $this->argc; $i++) {
                $this->arguments[] = $this->argv[$i];
            }
            
        }
        
        return $this->arguments;
    }
9792
protected function resolveApplicationBootstrappers($app)
    {
        $app->make('Illuminate\Foundation\Bootstrap\HandleExceptions')->bootstrap($app);
        $app->make('Illuminate\Foundation\Bootstrap\RegisterFacades')->bootstrap($app);
        $app->make('Illuminate\Foundation\Bootstrap\SetRequestForConsole')->bootstrap($app);
        $app->make('Illuminate\Foundation\Bootstrap\RegisterProviders')->bootstrap($app);

        $this->getEnvironmentSetUp($app);

        $app->make('Illuminate\Foundation\Bootstrap\BootProviders')->bootstrap($app);

        foreach ($this->getPackageBootstrappers($app) as $bootstrap) {
            $app->make($bootstrap)->bootstrap($app);
        }

        $app->make('Illuminate\Contracts\Console\Kernel')->bootstrap();

        $app['router']->getRoutes()->refreshNameLookups();

        $app->resolving('url', function ($url, $app) {
            $app['router']->getRoutes()->refreshNameLookups();
        });
    }
249307
protected function normaliseArguments($name, $args = [])
    {
        // Allow service names of the form "%$ServiceName"
        if (substr($name, 0, 2) == '%$') {
            $name = substr($name, 2);
        }

        if (strstr($name, '(')) {
            list($name, $extraArgs) = ClassInfo::parse_class_spec($name);
            if ($args) {
                $args = array_merge($args, $extraArgs);
            } else {
                $args = $extraArgs;
            }
        }
        $name = trim($name);
        return [$name, $args];
    }
811239
public function processArguments()
    {
        if(($this->getOption('core.decode_utf8')))
        {
            $sFunction = '';

            if(function_exists('iconv'))
            {
                $sFunction = "iconv";
            }
            elseif(function_exists('mb_convert_encoding'))
            {
                $sFunction = "mb_convert_encoding";
            }
            elseif($this->getOption('core.encoding') == "ISO-8859-1")
            {
                $sFunction = "utf8_decode";
            }
            else
            {
                throw new \Jaxon\Exception\Error($this->trans('errors.request.conversion'));
            }

            $mFunction = array(&$this, '__argumentDecodeUTF8_' . $sFunction);
            array_walk($this->aArgs, $mFunction);
            $this->setOption('core.decode_utf8', false);
        }

        return $this->aArgs;
    }