自学教程：C++ CheckArgument函数代码示例

int ReminderGlue::FindReminder(lua_State* lua){	CheckArgument(lua, 1, LUA_TSTRING);	CheckArgument(lua, 2, LUA_TSTRING);	CheckArgument(lua, 3, LUA_TSTRING);	UnicodeString server = AsUnicode(lua_tostring(lua, 1));	UnicodeString channel = AsUnicode(lua_tostring(lua, 2));	UnicodeString searchString = AsUnicode(lua_tostring(lua, 3));	ReminderManager::ReminderIteratorRange reminders =			reminderManager_->FindReminders(server, channel, searchString);	int reminderCount = std::distance(reminders.first, reminders.second);	lua_createtable(lua, reminderCount, 0);	int mainTableIndex = lua_gettop(lua);	for (ReminderManager::ReminderIterator reminder = reminders.first; reminder			!= reminders.second; ++reminder)	{		lua_createtable(lua, 2, 0);		int subTableIndex = lua_gettop(lua);		lua_pushinteger(lua, reminder->Timestamp - time(0));		lua_rawseti(lua, subTableIndex, 1);		lua_pushstring(lua, AsUtf8(reminder->Message).c_str());		lua_rawseti(lua, subTableIndex, 2);		int currentMainIndex = std::distance(reminders.first, reminder) + 1;		lua_rawseti(lua, mainTableIndex, currentMainIndex);	}	return 1;}

void TimerStat::start() {  if(__CVC4_USE_STATISTICS) {    CheckArgument(!d_running, *this, "timer already running");    clock_gettime(CLOCK_MONOTONIC, &d_start);    d_running = true;  }}/* TimerStat::start() */

static AstExpression CheckFunctionCall(AstExpression expr){	AstExpression arg;	Type ty;	AstNode *tail;	int argNo, argFull;	if (expr->kids[0]->op == OP_ID && LookupID(expr->kids[0]->val.p) == NULL)	{		expr->kids[0]->ty = DefaultFunctionType;		expr->kids[0]->val.p = AddFunction(expr->kids[0]->val.p, DefaultFunctionType, TK_EXTERN);	}	else	{		expr->kids[0] = CheckExpression(expr->kids[0]);	}	expr->kids[0] = Adjust(expr->kids[0], 1);	ty = expr->kids[0]->ty;	if (! (IsPtrType(ty) && IsFunctionType(ty->bty)))	{		Error(&expr->coord, "The left operand must be function or function pointer");	    ty = DefaultFunctionType;	}	else	{		ty = ty->bty;	}	tail = (AstNode *)&expr->kids[1];	arg = expr->kids[1];	argNo = 1;	argFull = 0;	while (arg != NULL && ! argFull)	{		*tail = (AstNode)CheckArgument((FunctionType)ty, arg, argNo, &argFull);		tail = &(*tail)->next;		arg = (AstExpression)arg->next;		argNo++;	}	*tail = NULL;	if (arg != NULL)	{		while (arg != NULL)		{			CheckExpression(arg);			arg = (AstExpression)arg->next;		}		Error(&expr->coord, "Too many arguments");	}	else if (argNo < LEN(((FunctionType)ty)->sig->params))	{		Error(&expr->coord, "Too few arguments");	}	expr->ty = ty->bty;	return expr;}

void LogicInfo::disableReals() {  CheckArgument(!d_locked, *this, "This LogicInfo is locked, and cannot be modified");  d_logicString = "";  d_reals = false;  if(!d_integers) {    disableTheory(THEORY_ARITH);  }}

void StatisticsRegistry::unregisterStat(Stat* s) throw(CVC4::IllegalArgumentException) {#ifdef CVC4_STATISTICS_ON  StatSet& stats = current()->d_stats;  CheckArgument(stats.find(s) != stats.end(), s,                "Statistic `%s' was not registered with this registry.",                s->getName().c_str());  stats.erase(s);#endif /* CVC4_STATISTICS_ON */}/* StatisticsRegistry::unregisterStat() */

const Datatype& DatatypeType::getDatatype() const {  NodeManagerScope nms(d_nodeManager);  if( d_typeNode->isParametricDatatype() ) {    CheckArgument( (*d_typeNode)[0].getKind() == kind::DATATYPE_TYPE, this);    const Datatype& dt = (*d_typeNode)[0].getConst<Datatype>();    return dt;  } else {    return d_typeNode->getDatatype();  }}

Type& Type::operator=(const Type& t) {  CheckArgument(d_typeNode != NULL, this, "Unexpected NULL typenode pointer!");  CheckArgument(t.d_typeNode != NULL, t, "Unexpected NULL typenode pointer!");  if(this != &t) {    if(d_nodeManager == t.d_nodeManager) {      NodeManagerScope nms(d_nodeManager);      *d_typeNode = *t.d_typeNode;    } else {      // This happens more than you think---every time you set to or      // from the null Type.  It's tricky because each node manager      // must be in play at the right time.      NodeManagerScope nms1(d_nodeManager);      *d_typeNode = TypeNode::null();      NodeManagerScope nms2(t.d_nodeManager);      *d_typeNode = *t.d_typeNode;      d_nodeManager = t.d_nodeManager;    }  }  return *this;}

void LogicInfo::setLogicString(std::string logicString) throw(IllegalArgumentException) {  CheckArgument(!d_locked, *this, "This LogicInfo is locked, and cannot be modified");  for(TheoryId id = THEORY_FIRST; id < THEORY_LAST; ++id) {    d_theories[id] = false;// ensure it's cleared  }  d_sharingTheories = 0;  // Below, ONLY use enableTheory()/disableTheory() rather than  // accessing d_theories[] directly.  This makes sure to set up  // sharing properly.  enableTheory(THEORY_BUILTIN);  enableTheory(THEORY_BOOL);  const char* p = logicString.c_str();  if(!strcmp(p, "QF_SAT") || *p == '/0') {    // propositional logic only; we're done.    p += 6;  } else if(!strcmp(p, "QF_ALL_SUPPORTED")) {    // the "all theories included" logic, no quantifiers    enableEverything();    disableQuantifiers();    p += 16;  } else if(!strcmp(p, "ALL_SUPPORTED")) {    // the "all theories included" logic, with quantifiers    enableEverything();    enableQuantifiers();    p += 13;  } else {    if(!strncmp(p, "QF_", 3)) {      disableQuantifiers();      p += 3;    } else {      enableQuantifiers();    }    if(!strncmp(p, "AX", 2)) {      enableTheory(THEORY_ARRAY);      p += 2;    } else {      if(*p == 'A') {        enableTheory(THEORY_ARRAY);        ++p;      }      if(!strncmp(p, "UF", 2)) {        enableTheory(THEORY_UF);        p += 2;      }      if(!strncmp(p, "BV", 2)) {        enableTheory(THEORY_BV);        p += 2;      }      if(!strncmp(p, "DT", 2)) {        enableTheory(THEORY_DATATYPES);        p += 2;      }      if(!strncmp(p, "IDL", 3)) {        enableIntegers();        disableReals();        arithOnlyDifference();        p += 3;      } else if(!strncmp(p, "RDL", 3)) {        disableIntegers();        enableReals();        arithOnlyDifference();        p += 3;      } else if(!strncmp(p, "IRDL", 4)) {        // "IRDL" ?! --not very useful, but getLogicString() can produce        // that string, so we really had better be able to read it back in.        enableIntegers();        enableReals();        arithOnlyDifference();        p += 4;      } else if(!strncmp(p, "LIA", 3)) {        enableIntegers();        disableReals();        arithOnlyLinear();        p += 3;      } else if(!strncmp(p, "LRA", 3)) {        disableIntegers();        enableReals();        arithOnlyLinear();        p += 3;      } else if(!strncmp(p, "LIRA", 4)) {        enableIntegers();        enableReals();        arithOnlyLinear();        p += 4;      } else if(!strncmp(p, "NIA", 3)) {        enableIntegers();        disableReals();        arithNonLinear();        p += 3;      } else if(!strncmp(p, "NRA", 3)) {        disableIntegers();        enableReals();        arithNonLinear();        p += 3;      } else if(!strncmp(p, "NIRA", 4)) {        enableIntegers();        enableReals();//.........这里部分代码省略.........

SubrangeType::SubrangeType(const Type& t)  throw(IllegalArgumentException) :  Type(t) {  CheckArgument(isNull() || isSubrange(), this);}

void Begin(int argc, char* argv[]) {	char task[64],		buffer[1024];	int i,		cmdLength=0,		cmdBegin=1,		function;	Task* workingtask = NULL;		// vérification arguments	function = CheckArgument(argv[1]);	int AcceptNull = (function==_H||function==_CF||function==_R||function==_I||function==_LT||function==_LD);		// début de traitement	switch (AcceptNull)	{		// cas des commandes qui n'ont pas besoin d'une tache valide		case true :		{			switch (function)			{				case _R : printf("-- number of running task"); TaskFunction = Running; break;				case _CF : printf("-- open configuration file/n"); TaskFunction = OpenConfig; break;				case _H : printf("-- help of the program/n"); TaskFunction = Help; break;				case _I : printf("-- number of running instances"); TaskFunction = Instances; break;				case _LT : printf("-- list all tasks/n"); TaskFunction = ListAllTasks; break;				case _LD : printf("-- list loaded tasks/n"); TaskFunction = ListLoadedTasks; break;			}			break;		}				// cas des commandes nécessitant une tache valide		default :		{			// nom de la tache			if (function != _A && argc > 2) sprintf(task, "%s", argv[2]);			else sprintf(task, "%s", DEFAULT_TASK);			// pointeur sur celle-ci			workingtask=GetTask(task);			if (workingtask==NULL) {				workingtask=LoadTask(task);				if (workingtask==NULL) {					workingtask=AddTask(task);					if (workingtask==NULL) {						// tache introuvable, plus de place						fprintf(stderr, "*** unable to work on task %s, exit/n", task);						exit(2);					}				}			}			// tache valide			switch (function)			{				case _L : printf("-- list %s task/n", task); TaskFunction = ListTask; break;				case _S : printf("-- start %s task/n", task); TaskFunction = StartTask; break;				case _D : printf("-- delete last command in %s task/n", task); TaskFunction = DeleteLastCommand; break;				case _X : printf("-- stop %s task/n", task); TaskFunction = StopTask; break;				case _C : printf("-- clean %s task/n", task); TaskFunction = CleanTask; break;				case _M : {					if (argc > 3) sprintf(DEFAULT_EDITOR, "%s", argv[3]);					printf("-- modify %s task/n", task);					TaskFunction = ModifyTask;					break;				}				case _T : cmdBegin+=2;				case _A : {					GetEnv("$PWD", addedCommand.wd);					sprintf(addedCommand.cmd, "%s", argv[cmdBegin]);					cmdLength = strlen(addedCommand.cmd);					for (i=cmdBegin+1; i<argc; i++) {						cmdLength += strlen(argv[i]);						if (cmdLength >= 1023) {							fprintf(stderr, "*** attention : command is too long (max. size 1024)/n");							fprintf(stderr, "                possible unexpected behavior/n"); 							break;						}						sprintf(buffer, " %s", argv[i]);						strncat(addedCommand.cmd, buffer, 1024);					}					printf("-- add '%s' to %s task/n", addedCommand.cmd, task);					TaskFunction = AddToTask;					break;				}				default : fprintf(stderr, "*** error while interpreting arguments : returning value %d/n", function); break;			}			break;		}	}		TaskFunction(workingtask);		if (workingtask!=NULL) {		if ((!workingtask->exec) && (!workingtask->demand))			workingtask->inuse=0;	}}

Arguments<U> Client<T,U>::ParseArguments(int argc, char *argv[], const size_t level,                                         const GetMetric default_a_ld,                                         const GetMetric default_b_ld,                                         const GetMetric default_c_ld) {  auto args = Arguments<U>{};  auto help = std::string{"/n* Options given/available:/n"};  // These are the options which are not for every client: they are optional  for (auto &o: options_) {    // Data-sizes    if (o == kArgM)  { args.m   = GetArgument(argc, argv, help, kArgM, size_t{512}); }    if (o == kArgN)  { args.n   = GetArgument(argc, argv, help, kArgN, size_t{512}); }    if (o == kArgK)  { args.k   = GetArgument(argc, argv, help, kArgK, size_t{512}); }    if (o == kArgKU) { args.ku  = GetArgument(argc, argv, help, kArgKU, size_t{128}); }    if (o == kArgKL) { args.kl  = GetArgument(argc, argv, help, kArgKL, size_t{128}); }    // Data-layouts    if (o == kArgLayout)   { args.layout      = GetArgument(argc, argv, help, kArgLayout, Layout::kRowMajor); }    if (o == kArgATransp)  { args.a_transpose = GetArgument(argc, argv, help, kArgATransp, Transpose::kNo); }    if (o == kArgBTransp)  { args.b_transpose = GetArgument(argc, argv, help, kArgBTransp, Transpose::kNo); }    if (o == kArgSide)     { args.side        = GetArgument(argc, argv, help, kArgSide, Side::kLeft); }    if (o == kArgTriangle) { args.triangle    = GetArgument(argc, argv, help, kArgTriangle, Triangle::kUpper); }    if (o == kArgDiagonal) { args.diagonal    = GetArgument(argc, argv, help, kArgDiagonal, Diagonal::kUnit); }    // Vector arguments    if (o == kArgXInc)    { args.x_inc    = GetArgument(argc, argv, help, kArgXInc, size_t{1}); }    if (o == kArgYInc)    { args.y_inc    = GetArgument(argc, argv, help, kArgYInc, size_t{1}); }    if (o == kArgXOffset) { args.x_offset = GetArgument(argc, argv, help, kArgXOffset, size_t{0}); }    if (o == kArgYOffset) { args.y_offset = GetArgument(argc, argv, help, kArgYOffset, size_t{0}); }    // Matrix arguments    if (o == kArgALeadDim) { args.a_ld     = GetArgument(argc, argv, help, kArgALeadDim, default_a_ld(args)); }    if (o == kArgBLeadDim) { args.b_ld     = GetArgument(argc, argv, help, kArgBLeadDim, default_b_ld(args)); }    if (o == kArgCLeadDim) { args.c_ld     = GetArgument(argc, argv, help, kArgCLeadDim, default_c_ld(args)); }    if (o == kArgAOffset)  { args.a_offset = GetArgument(argc, argv, help, kArgAOffset, size_t{0}); }    if (o == kArgBOffset)  { args.b_offset = GetArgument(argc, argv, help, kArgBOffset, size_t{0}); }    if (o == kArgCOffset)  { args.c_offset = GetArgument(argc, argv, help, kArgCOffset, size_t{0}); }    if (o == kArgAPOffset) { args.ap_offset= GetArgument(argc, argv, help, kArgAPOffset, size_t{0}); }    // Scalar result arguments    if (o == kArgDotOffset)  { args.dot_offset = GetArgument(argc, argv, help, kArgDotOffset, size_t{0}); }    if (o == kArgNrm2Offset)  { args.nrm2_offset = GetArgument(argc, argv, help, kArgNrm2Offset, size_t{0}); }    if (o == kArgAsumOffset)  { args.asum_offset = GetArgument(argc, argv, help, kArgAsumOffset, size_t{0}); }    if (o == kArgImaxOffset)  { args.imax_offset = GetArgument(argc, argv, help, kArgImaxOffset, size_t{0}); }    // Scalar values     if (o == kArgAlpha) { args.alpha = GetArgument(argc, argv, help, kArgAlpha, GetScalar<U>()); }    if (o == kArgBeta)  { args.beta  = GetArgument(argc, argv, help, kArgBeta, GetScalar<U>()); }  }  // These are the options common to all routines  args.platform_id    = GetArgument(argc, argv, help, kArgPlatform, size_t{0});  args.device_id      = GetArgument(argc, argv, help, kArgDevice, size_t{0});  args.precision      = GetArgument(argc, argv, help, kArgPrecision, Precision::kSingle);  #ifdef CLBLAST_REF_CLBLAS    args.compare_clblas = GetArgument(argc, argv, help, kArgCompareclblas, 1);  #else    args.compare_clblas = 0;  #endif  #ifdef CLBLAST_REF_CBLAS    args.compare_cblas  = GetArgument(argc, argv, help, kArgComparecblas, 1);  #else    args.compare_cblas = 0;  #endif  args.step           = GetArgument(argc, argv, help, kArgStepSize, size_t{1});  args.num_steps      = GetArgument(argc, argv, help, kArgNumSteps, size_t{0});  args.num_runs       = GetArgument(argc, argv, help, kArgNumRuns, size_t{10});  args.print_help     = CheckArgument(argc, argv, help, kArgHelp);  args.silent         = CheckArgument(argc, argv, help, kArgQuiet);  args.no_abbrv       = CheckArgument(argc, argv, help, kArgNoAbbreviations);  warm_up_            = CheckArgument(argc, argv, help, kArgWarmUp);  // Prints the chosen (or defaulted) arguments to screen. This also serves as the help message,  // which is thus always displayed (unless silence is specified).  if (!args.silent) { fprintf(stdout, "%s/n", help.c_str()); }  // Comparison against a non-BLAS routine is not supported  if (level == 4) { // level-4 == level-X    if (args.compare_clblas != 0 || args.compare_cblas != 0) {      if (!args.silent) {        fprintf(stdout, "* Disabling clBLAS and CPU BLAS comparisons for this non-BLAS routine/n/n");      }    }    args.compare_clblas = 0;    args.compare_cblas = 0;  }  // Comparison against clBLAS or a CPU BLAS library is not supported in case of half-precision  if (args.precision == Precision::kHalf) {    if (args.compare_clblas != 0 || args.compare_cblas != 0) {      if (!args.silent) {        fprintf(stdout, "* Disabling clBLAS and CPU BLAS comparisons for half-precision/n/n");      }    }    args.compare_clblas = 0;    args.compare_cblas = 0;  }  // Returns the arguments//.........这里部分代码省略.........