std::shared_ptr<const Object> Function::call(
const std::vector<std::shared_ptr<const Object> >& args,
const std::shared_ptr<Environment>& env) const
{
size_t len = args.size();
if (len == d_args.size())
return internalCall(args, env);
else if (len < d_args.size())
{
std::vector<std::string> newNames;
for(size_t i = len; i < d_args.size(); i++)
newNames.push_back(d_args[i]);
auto newargs = args;
size_t size = newargs.size();
return std::make_shared<const Function>(newNames,
[this, newargs, size]
(const std::vector<std::shared_ptr<const Object> >& args,
const std::shared_ptr<Environment>& env) mutable {
newargs.resize(size);
newargs.insert(newargs.end(), args.begin(), args.end());
return call(newargs, env);
});
}
else
{
auto result = internalCall(args, env)->evaluateCompletely();
auto func = toType<Function>(result, false);
if (func)
{
std::vector<std::shared_ptr<const Object> > newargs(
args.begin()+d_args.size(), args.end());
return func->call(newargs, env);
}
else
{
std::stringstream ss;
ss << "Wrong number of arguments for ";
print(ss);
ss << " (" << len << " for " << d_args.size();
throw std::runtime_error(ss.str());
}
}
}
bool GenericPipe::setSource(
const utils::PipeArgs& args)
{
utils::PipeArgs newargs(args);
//Interlace video handling.
if(newargs.whf.format & INTERLACE_MASK) {
setMdpFlags(newargs.mdpFlags, utils::OV_MDP_DEINTERLACE);
}
utils::Whf whf(newargs.whf);
//Extract HAL format from lower bytes. Deinterlace if interlaced.
whf.format = utils::getColorFormat(whf.format);
//Get MDP equivalent of HAL format.
whf.format = utils::getMdpFormat(whf.format);
newargs.whf = whf;
//Cache if user wants 0-rotation
mRotUsed = newargs.rotFlags & utils::ROT_0_ENABLED;
mRotDownscaleOpt = newargs.rotFlags & utils::ROT_DOWNSCALE_ENABLED;
mRot->setSource(newargs.whf);
mRot->setFlags(newargs.mdpFlags);
return mCtrlData.ctrl.setSource(newargs);
}
/****** uti/sge_execvlp() ****************************************
*
* NAME
* sge_execvlp -- like execve, but search the path
*
* SYNOPSIS
* #include "uti/execvlp.h"
* int sge_execvlp (const char *file, char *const argv[], char *const envp[])
*
* FUNCTION
* A version of execve that does a path search for the executable
* like execlp/execvp.
*
* INPUTS
* file - name of executable
* argv - null-terminated list of arguments
* envp - null-terminated list of environment elements
*
* RESULT
* on success, the function will not return (it execs)
* -1 if the exec fails
******************************************************************************/
int
sge_execvlp (const char *file, char *const argv[], char *const envp[])
{
char *path;
char execpath[SGE_PATH_MAX];
char *component;
int first = 1;
path = getenv ("PATH");
if (!path) /* use file directly if no path */
return execve (file, argv, envp);
if (strchr (file, '/')) { /* directory path -- don't search */
int late_errno = errno;
errno = 0;
execve (file, argv, envp);
if (errno == ENOEXEC) {
char **newargv;
errno = late_errno;
newargv = newargs (file, argv);
if (!newargv) return -1;
execve (newargv[0], newargv, envp);
free (newargv);
}
return -1;
}
/* Else try path components */
path = strdup (path);
while ((component = strtok ((first ? path : NULL), ":"))) {
int late_errno = errno;
first = 0;
execpath[0] = '\0';
if (strlen (component) != 0) { /* else current directory */
if ((sge_strlcat(execpath, component, sizeof(execpath))
>= sizeof(execpath))
|| (sge_strlcat(execpath, "/", sizeof(execpath))
>= sizeof(execpath)))
continue;
}
if (sge_strlcat(execpath, file, sizeof(execpath)) >= sizeof(execpath))
continue;
errno = 0;
execve (execpath, argv, envp);
if (errno == ENOEXEC) {
char **newargv;
newargv = newargs (file, argv);
if (!newargv) return -1;
execve (newargv[0], newargv, envp);
free (newargv);
errno = late_errno;
sge_free(&path);
return -1;
}
if (errno != ENOENT)
return -1;
}
sge_free(&path);
return -1;
}
