void Loop::parse(vector<string> args) {
assert(args.size() > 0, "-loop requires arguments\n");
if (args[0].size() > 2 && args[0][0] == '-' && args[0][1] == '-') { // infinite loop mode
vector<string> newArgs(args.size());
for (size_t i = 0; i < args.size(); i++) {
if (args[i].size() > 1 && args[i][0] == '-' && args[i][1] == '-') {
newArgs[i] = args[i].substr(1, args[i].size() - 1);
} else {
newArgs[i] = args[i];
}
}
for (;;) { parseCommands(newArgs); }
} else { // finite loop mode
vector<string> newArgs(args.size() - 1);
for (size_t i = 0; i < newArgs.size(); i++) {
if (args[i+1].size() > 1 && args[i+1][0] == '-' && args[i+1][1] == '-') {
newArgs[i] = args[i+1].substr(1, args[i+1].size() - 1);
} else {
newArgs[i] = args[i+1];
}
}
for (int i = 0; i < readInt(args[0]); i++) {
parseCommands(newArgs);
}
}
}
//-------------------------------------------------------------------------------------------------
Args Args::operator+(const Value& arg) const
{
Args newArgs(*this);
newArgs += arg;
return newArgs;
}
void BinDataInfo::Functions::UUID::call(JSContext* cx, JS::CallArgs args) {
boost::optional<mongo::UUID> uuid;
if (args.length() == 0) {
uuid = mongo::UUID::gen();
} else {
uassert(ErrorCodes::BadValue, "UUID needs 0 or 1 arguments", args.length() == 1);
auto arg = args.get(0);
std::string str = ValueWriter(cx, arg).toString();
// For backward compatibility quietly accept and convert 32-character hex strings to
// BinData(3, ...) as used for the deprecated UUID v3 BSON type.
if (str.length() == 32) {
hexToBinData(cx, bdtUUID, arg, args.rval());
return;
}
uuid = uassertStatusOK(mongo::UUID::parse(str));
};
ConstDataRange cdr = uuid->toCDR();
std::string encoded = mongo::base64::encode(cdr.data(), cdr.length());
JS::AutoValueArray<2> newArgs(cx);
newArgs[0].setInt32(newUUID);
ValueReader(cx, newArgs[1]).fromStringData(encoded);
getScope(cx)->getProto<BinDataInfo>().newInstance(newArgs, args.rval());
}
void ShaderEditASM::LogFunctionPre(uint updateID, const char *funcName, uint funcIndex, const FunctionArgs & args)
{
//Return if GL calls cannot be made
if(!DriverAvailable())
{
return;
}
//Create a access copy of the arguments
FunctionArgs newArgs(args);
//Perform the action
switch(updateID)
{
case(CBI_glGenPrograms) :
CreateARBShadersPre(newArgs);
break;
case(CBI_glDeletePrograms) :
DeleteARBShaders(newArgs);
break;
case(CBI_glBindProgram) :
BindARBShaderPre(newArgs);
break;
case(CBI_glProgramString) :
case(CBI_glLoadProgram) :
SetARBShaderReadyPre(updateID,newArgs);
break;
default:
LOGERR(("ShaderEditASM::LogFunctionPre - Unknown update ID"));
}
}
void ApplyArgs(const sptr<BShell>& shell, const ICommand::ArgList& args, bool useArg0)
{
shell->GetArguments(&m_oldArgs);
if (useArg0) shell->SetArguments(args);
else {
SVector<SValue> newArgs(args);
if (m_oldArgs.CountItems() > 0)
newArgs.ReplaceItemAt(m_oldArgs[0], 0);
shell->SetArguments(newArgs);
}
}
void QmitkCommonExtPlugin::startNewInstance(const QStringList &args, const QStringList& files)
{
QStringList newArgs(args);
#ifdef Q_OS_UNIX
newArgs << QString("--") +berry::Platform::ARG_NEWINSTANCE;
#else
newArgs << QString("/") + berry::Platform::ARG_NEWINSTANCE;
#endif
newArgs << files;
QProcess::startDetached(qApp->applicationFilePath(), newArgs);
}
void Time::parse(vector<string> args) {
if (args.size() == 0) {
printf("%3.3f s\n", currentTime());
return;
}
vector<string> newArgs(args.size());
for (size_t i = 0; i < args.size(); i++) {
if (args[i].size() > 1 && args[i][0] == '-' && args[i][1] == '-') {
newArgs[i] = args[i].substr(1, args[i].size() - 1);
} else {
newArgs[i] = args[i];
}
}
float t1 = currentTime();
parseCommands(newArgs);
float t2 = currentTime();
printf("%3.3f s\n", t2 - t1);
}
std::unique_ptr<GrFragmentProcessor> Gr2PtConicalGradientEffect::Make(
const GrGradientEffect::CreateArgs& args) {
const SkTwoPointConicalGradient& shader =
*static_cast<const SkTwoPointConicalGradient*>(args.fShader);
SkMatrix matrix;
if (!shader.getLocalMatrix().invert(&matrix)) {
return nullptr;
}
if (args.fMatrix) {
SkMatrix inv;
if (!args.fMatrix->invert(&inv)) {
return nullptr;
}
matrix.postConcat(inv);
}
GrGradientEffect::CreateArgs newArgs(args.fContext, args.fShader, &matrix, args.fWrapMode,
args.fDstColorSpace);
// Data and matrix has to be prepared before constructing TwoPointConicalEffect so its parent
// class can have the right matrix to work with during construction.
TwoPointConicalEffect::Data data(shader, matrix);
return TwoPointConicalEffect::Make(newArgs, data);
}
bool GLRenderCallCache::SetRenderCall(uint updateID, const char *funcName, const FunctionArgs & args)
{
//Check if setting a new render call while one is "active"
if(isRenderCallSet)
{
LOGERR(("GLRenderCallCache::SetRenderCall - Setting a render call while an existing call is active?"));
isRenderCallSet = false;
}
//Create a access copy of the arguments
FunctionArgs newArgs(args);
//Switch based on the render type
switch(updateID)
{
case(CBI_glDrawArrays) :
newArgs.Get(iMode);
newArgs.Get(iFirst);
newArgs.Get(iCount);
break;
case(CBI_glDrawElements) :
newArgs.Get(iMode);
newArgs.Get(iCount);
newArgs.Get(iType);
newArgs.Get(iPtrIndices);
break;
case(CBI_glDrawRangeElements) :
newArgs.Get(iMode);
newArgs.Get(iStart);
newArgs.Get(iEnd);
newArgs.Get(iCount);
newArgs.Get(iType);
newArgs.Get(iPtrIndices);
break;
case(CBI_glMultiDrawArrays) :
newArgs.Get(iMode);
newArgs.Get(iPtrFirst);
newArgs.Get(iPtrCount);
newArgs.Get(iPrimcount);
break;
case(CBI_glMultiDrawElements) :
newArgs.Get(iMode);
newArgs.Get(iPtrCount);
newArgs.Get(iType);
newArgs.Get(iPtrIndices);
newArgs.Get(iPrimcount);
//Manually assign the pointer to index arrays
iPtrPtrIndices = (const GLvoid **)iPtrIndices;
break;
default:
LOGERR(("GLRenderCallCache::SetRenderCall - Unknown render call %s",funcName));
return false;
break;
}
//Store the current render type
currRenderType = updateID;
//Flag that a rendre call is set
isRenderCallSet = true;
return true;
}
void InterceptLog::GetFunctionString(const FunctionData *funcData,uint index, const FunctionArgs & args, string &retString)
{
//Append the function name first
retString = funcData->GetName() + "(";
//Get a copy of the arguments
FunctionArgs newArgs(args);
//Loop for all the parameters
for(uint i=0;i<funcData->parameterArray.size();i++)
{
// LOGERR(("arg.size()=%d\n",funcData->parameterArray.size()));
//Get the parameter
const ParameterData * paramData = &funcData->parameterArray[i];
LOGERR(("The paramDateName:%d, %s\n",paramData->type,paramData->paramName.c_str()));
//Determine if we are processing pointers
bool isPointer=false;
if(paramData->pointerCount > 0 || paramData->length != -1)
{
isPointer=true;
}
//Get the value
ParamValue value;
////¼Ó²âÊÔÖ¸Õë
if(strcmp((funcData->GetName()).c_str(),"glLightfv")==0&&isPointer){
const GLfloat* V; newArgs.Get(V);
value.pointerValue =(void*) V;
LOGERR(("The length of this parametre is : lengh = %d\n ,Count = %d\n ", paramData->length,paramData->pointerCount));
LOGERR(("glLightfv:%f,%f,%f,%f\n",V[0],V[1],V[2],V[3]));
//LOGERR(("²ÎÊýÐòºÅ%d\n",i))
}
////²âÊÔÖ¸ÕëÍê±Ï
else if(!GetNextValue(paramData->GetGLType(),newArgs,isPointer, value))
{
break;
}
//Test if this is an array value
if(paramData->length != -1)
{
bool isArrayOfPointers = false;
//Test for an array of pointers
if(paramData->pointerCount > 0)
{
isArrayOfPointers = true;
}
//Assign the array
void * array = value.pointerValue;
//Loop and print the array
retString += "[";
for(uint i2=0;i2<(uint)paramData->length;i2++)
{
//Get the value from the array
if(!GetNextArrayValue(paramData->GetGLType(),&array,isArrayOfPointers, value))
{
break;
}
//Convert and print the value
retString += ConvertParam(value,isArrayOfPointers,paramData);
//Add a comma
if(i2 != (uint)(paramData->length - 1))
{
retString += ",";
}
}
retString += "]";
}
else
{
//Just get the single value
retString += ConvertParam(value,isPointer,paramData);
}
//Add a comma if there are more parameters
if(i != funcData->parameterArray.size() - 1)
{
retString += ",";
}
}
//If there are no parameters (unknown function)
if(funcData->parameterArray.size() == 0)
{
retString += " ??? ";
}
//Close the bracket
retString += ")";
}
