/*********************************************************************
* オプション設定
*********************************************************************
*/
void optionCheck()
{
if(IsOpt('h')||IsOpt('?')||IsOpt('/')||IsOpt('-')) {
usage();exit(0);
}
if(IsOpt('l')) {
log_fp = fopen( Opt('l') , "wb" );
}
if(IsOpt('u')) {
upfile = sp_skip(Opt('u')); // upload file.
}
if(IsOpt('b')) {
sscanf(Opt('b'),"%d",&baudrate); // Get BaudRate
printf("%d\n",baudrate);
}
if(IsOpt('d')) {
opt_d=1;
}
if(IsOpt('c')) {
com_port = Opt('c'); // COM Port No.
}else{
com_port = comXX;
sprintf(comXX,"%d",RS_printinfo(0));
printf("Open COM%s:\n",comXX);
}
}
/**
* The default Bitcoin XT subversion field according to BIP 14 spec
*/
std::string XTSubVersion()
{
std::vector<std::string> comments = Opt().UAComment();
if (Opt().IsStealthMode())
return FormatSubVersion("Satoshi", CLIENT_VERSION, comments, "");
if (!Opt().HidePlatform()) {
std::vector<std::string> p = GetPlatformDetails();
comments.insert(comments.end(), p.begin(), p.end());
}
return FormatSubVersion(CLIENT_NAME, CLIENT_VERSION, comments, CLIENT_VERSION_XT_SUBVER);
}
int
set_current_field(FORM *f, FIELD *c)
{
if (!f || !c || c->form != f)
return (E_BAD_ARGUMENT);
if (!Opt(c, O_ACTIVE) || !Opt(c, O_VISIBLE))
return (E_REQUEST_DENIED);
if (!Status(f, POSTED)) {
C(f) = c;
P(f) = c->page;
return (E_OK);
}
if (Status(f, DRIVER))
return (E_BAD_STATE);
if (c != C(f)) {
if (_validate(f)) {
int v;
term_field(f);
if (c -> page != P(f)) { /* page change */
term_form(f);
v = _set_form_page(f, c->page, c);
init_form(f);
} else
v = _set_current_field(f, c);
init_field(f);
(void) _update_current(f);
return (v);
} else
return (E_INVALID_FIELD);
}
return (E_OK);
}
indexmap_storage_pair (PyObject * X, bool allow_copy, const char * name ) {
try {
numpy_interface::numpy_extractor<indexmap_type,value_type> E(X, allow_copy);
this->indexmap_ = E.indexmap(); this->storage_ = E.storage();
}
catch(numpy_interface::copy_exception s){// intercept only this one...
TRIQS_RUNTIME_ERROR<< " construction of a "<< name <<" from a numpy "
<<"\n T = "<< triqs::utility::typeid_name(value_type())
// <<"\n rank = "<< IndexMapType::domain_type::rank//this->rank
<<"\n Opt = "<< triqs::utility::typeid_name(Opt())
<<"\nfrom the python object \n"<< numpy_interface::object_to_string(X)
<<"\nThe error was :\n "<<s.what();
}
}
/* Procedure to print a counter */
int PutCtr ( long long Val, char * Buf )
{
int Power = 0 ;
int Cnt ;
if ( Opt('h') )
{
while ( Val >= 10000 )
{
Val = Val >> 10 ;
Power ++ ;
}
Cnt = sprintf ( Buf, "%lld%c", Val, " KMGTPEZY" [ Power ] ) ;
}
else
{
/* _checkfield - invoke check_field function associated with field type t. */
int
_checkfield(FIELDTYPE *t, FIELD *f, char *arg)
{
if (!t)
return (TRUE);
if (Opt(f, O_NULLOK)) {
char *v = Buf(f);
while (*v && *v == ' ')
++v;
if (!*v)
return (TRUE); /* empty field */
}
if (Status(t, LINKED))
return (_checkfield(TypeL(t), f, ArgL(arg)) ||
_checkfield(TypeR(t), f, ArgR(arg)));
else
if (Fcheck(t))
return ((*Fcheck(t)) (f, arg));
return (TRUE);
}
//.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.- DtOptItem::ParseOpt -.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-.-
//
void DtOptItem::ParseOpt(DtOptItem* Options, int NumOpt, int argc, char* argv[],
list<wstring>& FreeArgs)
{
// First assign default values to all options
for (int i=0; i<NumOpt; i++)
{
Options[i].m_Option.m_Type = Options[i].m_Type;
switch (Options[i].m_Type)
{
case OPT_TYPE_BOOL:
case OPT_TYPE_INT:
Options[i].m_Option.m_IntValue = Options[i].m_IntValue;
break;
case OPT_TYPE_INT64:
Options[i].m_Option.m_Int64Value = Options[i].m_Int64Value;
break;
case OPT_TYPE_DOUBLE:
Options[i].m_Option.m_DoubleValue = Options[i].m_DoubleValue;
break;
case OPT_TYPE_STRING:
break;
case OPT_TYPE_STRING_LIST:
Options[i].m_Option.m_Strings.clear();
Options[i].m_Option.m_IntValue = Options[i].m_IntValue;
for (int j=0; j<Options[i].m_Option.m_IntValue; j++)
Options[i].m_Option.m_Strings.push_back(wstring());
break;
default:
assert(false);
}
}
bool CheckOptions = true;
// And then parse the actual commandline arguments
for (int i=1; i<argc; i++)
{
#ifdef WINBUILD
if (CheckOptions && (argv[i][0]=='-' || argv[i][0]=='/'))
#else
if (CheckOptions && argv[i][0]=='-')
#endif
{
if (argv[i][1] == '-')
{
CheckOptions = false;
continue;
}
string OptName(argv[i] + 1);
wstring WOptName(OptName.begin(), OptName.end());
int j;
for (j=0; j<NumOpt; j++)
{
if (Options[j].m_Name != WOptName)
continue;
Options[j].m_Option.m_IsSet = true;
if (Options[j].m_Type == OPT_TYPE_BOOL)
{
Options[j].m_Option.m_IntValue = true;
break;
}
if (Options[j].m_Type == OPT_TYPE_STRING_LIST)
{
if (i == argc - Options[j].m_IntValue)
throw DtOptException(L"Not enough arguments for command-line "
L"option: -%ls (expected %d)",
WOptName.c_str(),
Options[j].m_IntValue);
list<wstring>::iterator It=Options[j].m_Option.m_Strings.begin();
for (int k=0; k<Options[j].m_IntValue; k++)
{
string OptArg(argv[++i]);
*It = wstring(OptArg.begin(), OptArg.end());
It++;
}
break;
}
if (i == argc - 1)
throw DtOptException(L"Missing argument for command-line option: -%ls",
WOptName.c_str());
string OptArg(argv[++i]);
Options[j].m_Option.m_StrValue = wstring(OptArg.begin(), OptArg.end());
if (Options[j].m_Type == OPT_TYPE_DOUBLE)
Options[j].ParseDoubleOpt();
else if (Options[j].m_Type == OPT_TYPE_INT)
Options[j].ParseIntOpt();
else if (Options[j].m_Type == OPT_TYPE_INT64)
Options[j].ParseInt64Opt();
break;
}
if (j == NumOpt)
throw DtOptException(L"Unknown command-line option (-%ls) encountered",
WOptName.c_str());
} else {
string Opt(argv[i]);
FreeArgs.push_back(wstring(Opt.begin(), Opt.end()));
}
}
}
