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; }