bool TOptsParser::ParseUnknownShortOptWithinArg(size_t pos, size_t sop) {
YASSERT(pos < Argc_);
const TStringBuf arg(Argv_[pos]);
YASSERT(sop > 0);
YASSERT(sop < arg.length());
YASSERT(EIO_NONE != IsOpt(arg));
if (!Opts_->AllowUnknownCharOptions_)
ythrow TUsageException() << "unknown option '" << EscapeC(arg[sop])
<< "' in '" << arg << "'";
TempCurrentOpt_.Reset(new TOpt);
TempCurrentOpt_->AddShortName(arg[sop]);
sop += 1;
// mimic behavior of Opt: unknown option has arg only if char is last within arg
if (sop < arg.length()) {
return Commit(TempCurrentOpt_.Get(), 0, pos, sop);
}
pos += 1;
sop = 0;
if (pos == Argc_ || EIO_NONE != IsOpt(Argv_[pos])) {
return Commit(TempCurrentOpt_.Get(), 0, pos, 0);
}
return Commit(TempCurrentOpt_.Get(), Argv_[pos], pos + 1, 0);
}
/*********************************************************************
* オプション設定
*********************************************************************
*/
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);
}
}
void PointsCurveValue::GetVals()
{
if (IsOpt() && control.IsOptimization())
pVal = pOptData->GetParEstimate();
else if (IsVary() && (!control.IsSampleSim()))
pVal = pVaryData->GetVaryVal();
}
bool TOptsParser::ParseOptArg(size_t pos) {
YASSERT(pos < Argc_);
TStringBuf arg(Argv_[pos]);
const EIsOpt eio = IsOpt(arg);
YASSERT(EIO_NONE != eio);
if (EIO_DDASH == eio || EIO_PLUS == eio || (Opts_->AllowSingleDashForLong_ || !Opts_->HasAnyShortOption())) {
// long option
bool singleCharPrefix = EIO_DDASH != eio;
arg.Skip(singleCharPrefix ? 1 : 2);
TStringBuf optionName = arg.NextTok('=');
const TOpt* option = Opts_->FindLongOption(optionName);
if (!option) {
if (singleCharPrefix && !arg.IsInited()) {
return ParseShortOptArg(pos);
} else {
ythrow TUsageException() << "unknown option '" << optionName
<< "' in '" << Argv_[pos] << "'";
}
}
if (arg.IsInited()) {
if (option->HasArg_ == NO_ARGUMENT)
ythrow TUsageException() << "option " << optionName << " must have no arg";
return Commit(option, arg, pos + 1, 0);
}
++pos;
return ParseOptParam(option, pos);
} else {
return ParseShortOptArg(pos);
}
}
bool TOptsParser::ParseShortOptArg(size_t pos) {
YASSERT(pos < Argc_);
const TStringBuf arg(Argv_[pos]);
YASSERT(EIO_NONE != IsOpt(arg));
YASSERT(!arg.has_prefix("--"));
return ParseShortOptWithinArg(pos, 1);
}
void PointsCurveValue::SetForFlags(bool parIsActive)
{
if (IsOpt() && (!control.IsOptimization()))
pType = pcvFixed;
if (IsVary() && control.IsSampleSim())
pType = pcvFixed;
if (IsFixed() && control.IsOptimization() && pOptData && pOptData->wasActive)
pType = pcvOpt;
SetActive(parIsActive);
}
/*********************************************************************
* メイン
*********************************************************************
*/
int main(int argc,char **argv)
{
//オプション解析.
Getopt(argc,argv,"bl");
optionCheck();
if(IsOpt('p')) {
RS_printinfo(1);
return 0;
}
RS_terminal(com_port,baudrate);
if(log_fp!=NULL) fclose(log_fp);
return 0;
}
bool PointsCurveValue::SetupOK(SC_SetupErr& errData,
bool pIsLog)
{
if (IsOpt())
return pOptData->OptimizeSetupOK(errData);
else if (IsVary())
return pVaryData->VarySetupOK(errData);
SC_SetupErr parErr;
if (RealIsNull(pVal))
parErr.SetConstantError("data value not set");
else if (pIsLog && (pVal <= 1.0E-40))
parErr.SetConstantError("log curve is -ve");
return errData.SetupOK(pID, parErr);
}
bool TOptsParser::ParseShortOptWithinArg(size_t pos, size_t sop) {
YASSERT(pos < Argc_);
const TStringBuf arg(Argv_[pos]);
YASSERT(sop > 0);
YASSERT(sop < arg.length());
YASSERT(EIO_NONE != IsOpt(arg));
size_t p = sop;
char c = arg[p];
const TOpt* opt = Opts_->FindCharOption(c);
if (!opt)
return ParseUnknownShortOptWithinArg(pos, sop);
p += 1;
if (p == arg.length()) {
return ParseOptParam(opt, pos + 1);
}
if (opt->HasArg_ == NO_ARGUMENT) {
return Commit(opt, 0, pos, p);
}
return Commit(opt, arg + p, pos + 1, 0);
}
bool TOptsParser::ParseWithPermutation() {
YASSERT(Sop_ == 0);
YASSERT(Opts_->ArgPermutation_ == PERMUTE);
const size_t p0 = Pos_;
size_t pc = Pos_;
for (; pc < Argc_ && EIO_NONE == IsOpt(Argv_[pc]); ++pc) {
// count non-args
}
if (pc == Argc_) {
return CommitEndOfOptions(Pos_);
}
Pos_ = pc;
bool r = ParseOptArg(Pos_);
YASSERT(r);
while (Pos_ == pc) {
YASSERT(Sop_ > 0);
r = ParseShortOptWithinArg(Pos_, Sop_);
YASSERT(r);
}
size_t p2 = Pos_;
YASSERT(p2 - pc >= 1);
YASSERT(p2 - pc <= 2);
memrotate(Argv_ + p0, (p2 - p0) * sizeof(void*), (p2 - pc) * sizeof(void*));
bool r2 = ParseOptArg(p0);
YASSERT(r2);
return r2;
}
bool TOptsParser::DoNext() {
YASSERT(Pos_ <= Argc_);
if (Pos_ == Argc_)
return CommitEndOfOptions(Pos_);
if (GotMinusMinus_ && Opts_->ArgPermutation_ == RETURN_IN_ORDER) {
YASSERT(Sop_ == 0);
return Commit(0, Argv_[Pos_], Pos_ + 1, 0);
}
if (Sop_ > 0)
return ParseShortOptWithinArg(Pos_, Sop_);
size_t pos = Pos_;
const TStringBuf arg(Argv_[pos]);
if (EIO_NONE != IsOpt(arg)) {
return ParseOptArg(pos);
} else if (arg == "--") {
if (Opts_->ArgPermutation_ == RETURN_IN_ORDER) {
pos += 1;
if (pos == Argc_)
return CommitEndOfOptions(pos);
GotMinusMinus_ = true;
return Commit(0, Argv_[pos], pos + 1, 0);
} else {
return CommitEndOfOptions(pos + 1);
}
} else if (Opts_->ArgPermutation_ == RETURN_IN_ORDER) {
return Commit(0, arg, pos + 1, 0);
} else if (Opts_->ArgPermutation_ == REQUIRE_ORDER) {
return CommitEndOfOptions(Pos_);
} else {
return ParseWithPermutation();
}
}
void PointsCurveValue::SetVals()
{
if (IsOpt() && control.IsOptimization())
pOptData->SetParEstimate(pVal);
}
void PointsCurveValue::SetActive(bool parIsActive)
{
pOptIsActive = parIsActive && IsOpt() && control.IsOptimization();
pVaryIsActive = parIsActive && IsVary() && (!control.IsSampleSim());
}
int sci_optional_parameters(char * fname)
{
int m1, n1, l1;
// optional names must be stored in alphabetical order in opts
static rhs_opts opts[] = {{ -1, "v1", "d", 0, 0, 0},
{ -1, "v2", "d", 0, 0, 0},
{ -1, NULL, NULL, 0, 0}
};
int minrhs = 1, maxrhs = 1;
int minlhs = 1, maxlhs = 3;
int nopt, iopos, res;
char buffer_name[csiz]; // csiz used for character coding
nopt = NumOpt();
CheckRhs(minrhs, maxrhs + nopt);
CheckLhs(minlhs, maxlhs);
// first non optional argument
GetRhsVar( 1, "c", &m1, &n1, &l1);
if (get_optionals(fname, opts) == 0)
{
return 0;
}
// default values if optional arguments are not given: v1=[99] and v2=[3]
sciprint("number of optional parameters = %d\n", NumOpt());
sciprint("first optional parameters = %d\n", FirstOpt());
sciprint("FindOpt(v1) = %d\n", FindOpt("v1", opts));
sciprint("FindOpt(v2) = %d\n", FindOpt("v2", opts));
if (IsOpt(1, buffer_name))
{
sciprint("parameter 1 is optional: %s\n", buffer_name);
}
if (IsOpt(2, buffer_name))
{
sciprint("parameter 2 is optional: %s\n", buffer_name);
}
if (IsOpt(3, buffer_name))
{
sciprint("parameter 3 is optional: %s\n", buffer_name);
}
iopos = Rhs;
if (opts[0].position == -1)
{
iopos++;
opts[0].position = iopos;
opts[0].m = 1;
opts[0].n = 1;
opts[0].type = "d";
CreateVar(opts[0].position, opts[0].type, &opts[0].m, &opts[0].n, &opts[0].l);
*stk(opts[0].l) = 99.0;
}
if (opts[1].position == -1)
{
iopos++ ;
opts[1].position = iopos;
opts[1].m = 1;
opts[1].n = 1;
opts[1].type = "d";
CreateVar(opts[1].position, opts[1].type, &opts[1].m, &opts[1].n, &opts[1].l);
*stk(opts[1].l) = 3;
}
ex2c(stk(opts[0].l), &opts[0].m, &opts[0].n,
stk(opts[1].l), &opts[1].m, &opts[1].n);
// return the first argument (unchanged ) then v1 and v2
LhsVar(1) = 1;
LhsVar(2) = opts[0].position;
LhsVar(3) = opts[1].position;
return 0;
}
